x-shc directives
Layer 6. Services. Services
New line, in development. This page describes SHC as it is on the
devbranch, not the released product. See The new line.
An x-shc-* key asks SHC for something compose has no key for. Compose ignores every x- key, so SHC is the only thing that reads them, and the set is closed: ce modules/app/extension_lint.go xshcRegistry holds every key, the level it may sit at and what it may hold. The install render refuses a key or a value the registry does not allow, and shc validate runs the same check and lists every problem at once where the install stops at the first.
| Code | When |
|---|---|
X400330XSHUNK | A key under x-shc the registry does not hold, in any spelling or case. The refusal names the directive it most likely meant. |
X400331XSHLVL | A real directive at the wrong level, such as x-shc-scale at the top level. |
X400332XSHFLD | A field the directive does not take. |
X400333XSHVAL | A value the directive cannot honour, or a key SHC writes itself. |
In shc.yaml none of these keys exist. Each one is a plain key on the service, the secret or the top level, named on its entry below, and the loader turns it into the directive, so what follows applies to both files.
What the render does with them
Section titled “What the render does with them”Not every directive reaches the engine as written. The render reads each one and then does some of these:
- It keeps the key in the files it writes: the deployment’s
compose.yamland, on a cluster that runs replica projects, each replica’s project,replicas/<pod>-r<n>/compose.yaml(Replicas and pods). These are the rendered files below. - It turns the key into something else as well: a container label, a Traefik route, the deployment’s stored spec or its service rows.
A kept key changes nothing in the engine. docker and podman compose accept an x- key inside a service and ignore it, incus drops every x- key it does not read before it runs a project (ce core/executor/incus/translate.go), and apple skips them (ce core/executor/apple/project.go). The key stays because the rendered compose.yaml always parses where the app’s template may not, so a later scale, backup window or update reads the directive there, and an operator reading shc inspect sees what the app declared.
Directives an app writes
Section titled “Directives an app writes”| Directive | Level | Fields | Rendered files | Container label |
|---|---|---|---|---|
x-shc-scale | service | max, backup, witness | kept | shc.single_writer=true when max is 1 |
x-shc-health | service | restart_after | kept | shc.health.restart_after=<seconds> |
x-shc-live-labels | service | test, interval, timeout per label | kept | none |
x-shc-service-selectors | top level | a selector per service selector name, ending in :1 for a single backend, or a mapping of select, route and scope | kept | none |
x-shc-primary | service | true, false or a container port | kept | none |
x-shc-path | service | an absolute URL path | kept | none |
x-shc-path-strip | service | true or false | kept | none |
x-shc-upstream-tls | service | port, ca, server_name | kept | none |
x-shc-volumes | top level | size, access per volume | kept | none |
x-shc-vault | secret | a ref+vault:// reference | kept | none |
x-shc-reach | port | published | removed | none |
x-shc-scale
Section titled “x-shc-scale”Replica counts for one service. max is a hard ceiling: every path that changes a replica count asks it (ce modules/app/replica_ceiling.go), and a count above it is refused, never clamped. Declare max: 1 on every service whose data cannot take a second writer, such as a database, a broker or anything on one volume, because N replicas over one volume is N diverging copies. backup is how many replicas the service runs while a backup of the deployment runs, a whole number, usually 0 or 1. Absent, the backup leaves the service as it is. A restore opens no scale window, and a restore field is refused X400332XSHFLD like any unknown field (SHC-2459). witness names one group of the same app, and the service then prefers a node that holds none of that group’s members and still places when there is none (Groups: witnesses).
services: db: image: postgres:17 x-shc-scale: max: 1 backup: 0max is an unquoted whole number, 1 or more. A quoted "1", a fraction or a number below 1 is refused X400333XSHVAL, since each would read as no ceiling or a different one. backup takes a whole number, 0 or more, and a word such as keep, min or max is refused X400333XSHVAL. A stateful field is refused X400333XSHVAL naming the {% members %} block, which is how distinct copies of a service are written. A witness that names a group the app does not have, or one a member of a group declares, is refused X400333XSHVAL. An authored deploy.replicas or scale, or a --scale, above max is refused X400902SCLMAX. The members of one pod share the smallest max any of them states.
At render the key is kept. A service whose max is 1 also gets the container label shc.single_writer=true (ce modules/app/inject_single_writer.go): the node agent starts such a container only while its node holds its lease, and a node that loses its lease stops it without asking the control plane. The deployment’s stored spec records max as well, so an update or a move never runs two copies of that service at once (ce core/placement/movability.go SingleWriter). The backup window reads backup off the rendered compose.yaml (ce modules/app/scale_window.go).
In shc.yaml: scale on the service.
x-shc-health
Section titled “x-shc-health”How long a container may stay unhealthy before its node restarts it. restart_after is a duration in whole seconds (90s, 5m), a number of seconds, or 0 to turn the restart off. A service that declares none gets 5 minutes. Anything else is refused X400333XSHVAL.
services: web: image: ghcr.io/example/web:2.4.1 healthcheck: test: ["SHC-HTTP", ":8080/healthz"] x-shc-health: restart_after: 90sAt render the key is kept, and the service’s containers get the label shc.health.restart_after with the value in seconds, 90 here. The node’s unhealth watcher reads the label, not the key (ce modules/app/health_extension.go RestartAfterFromLabels), and logs X201026CTRRST when it restarts a container. It counts the same for a check the runtime runs and for an SHC probe the node runs, as in this example (Health probes).
In shc.yaml: health on the service.
x-shc-live-labels
Section titled “x-shc-live-labels”Labels whose value changes while a replica runs, such as which copy is the primary. Each entry is a label key and a command: test in a healthcheck’s shape (["CMD", ...] or ["CMD-SHELL", "..."]), interval, 30s unless stated and never under 5s, and timeout, 5s unless stated and shorter than the interval. SHC runs the test inside the container, and a run that exits 0 answers: the first line it prints, trimmed, is the label’s value, and a run that prints nothing or a value outside the label rules makes the label absent. A run that could not ask, one that times out, cannot be started or exits nonzero, is no answer: the label keeps the value it had, however long that goes on, and shc doctor names it (labelcheck.unknown). So exit nonzero when the command cannot tell, and print nothing to take the label away. A new value is taken once two answers in a row give it, so a value that flaps moves nothing. SHC does not act on the value by itself: a node selector’s @( ) reads it (Concepts: live labels), and so does a service selector the app declares under x-shc-service-selectors.
services: db: image: postgres:17 x-shc-live-labels: role: test: ["CMD", "cat", "/var/run/role"] interval: 30s timeout: 5sA reserved key (tenant, environment, stack, app, service, ordinal, group, member, node, location), a key under shc. or traefik., an empty test, an unknown field, or a bad interval or timeout is refused X400452LBLCHK. The command stays in the rendered compose.yaml, where compose reads $ as a variable, so a command that needs $ goes in a script in the app.
At render the key is kept, and the deployment’s stored spec carries the labels (ce modules/app/spec_services.go, deploymentspec.Service.LiveLabels). The node that runs the replica reads them there. The value is a label on the replica, not on the container.
In shc.yaml: live_labels on the service.
x-shc-service-selectors
Section titled “x-shc-service-selectors”Top level. A service selector is a name plus a selector over the labels of this deployment’s replicas. Each entry is one more name the deployment answers under, with a virtual IP of its own, and its backends are the replicas whose labels match now. It reads the same grammar as a node selector, and it reads service facts only: service, ordinal, group, member, the labels the app writes under compose labels:, and what its live labels last read. location and node are node selector terms, refused here X400454ALSDCL: where a replica runs is the deployment’s --where, never the app’s.
x-shc-service-selectors: postgres: role=primary:1 postgres-ro: role=replicaservices:{% members "postgres", default=1, max=7 as m %} postgres-{{ m.n }}: image: postgres:17 expose: - "5432" x-shc-live-labels: role: test: ["CMD-SHELL", "psql -U postgres -Atc \"select case when pg_is_in_recovery() then 'replica' else 'primary' end\""] interval: 5s timeout: 3s{% endmembers %}A trailing :1 is a count on the whole value: exactly one replica may answer. When no replica matches, or more than one does, the service selector has no backend and refuses connections, and shc status -s <deployment> says which. With no count every ready replica that matches answers, spread like a service’s own name. :1 is the only count: anything else after a last colon, such as :2, is refused naming :1. The count applies to the whole selector, so (role=primary & group=postgres):1 reads the same way.
To the selector a colon is plain value text, and one kind of label can hold one: a label the app writes under compose labels:. Live labels and the labels SHC derives never do. Text in parentheses is never a count, so (tag=app:1) is the value app:1 and (tag=app):1 is tag=app with the count. A bare tag=app:1, where tag is one of the app’s compose labels, reads two ways and is refused showing both spellings. A value that holds a colon before the count, tag=a:b:1, is refused the same way.
A service selector may also be a mapping that holds the selector under select, beside a route and a scope:
x-shc-service-selectors: postgres: role=primary:1 postgres-ro: select: role=replica route: any postgres-near: select: role=replica route: local scope: locationroute says how a node picks among the ready replicas the selector matches. nearest, the default and what a bare selector gets, sends a new connection to a replica on the dialling node, then to the ready replicas under the deepest location level it shares with any ready replica, comparing whole path segments, then to any if no level is shared. An empty location shares no level. any sends each new connection to the next ready replica in turn, wherever it runs, so reads spread over every replica instead of landing on the nearest. local sends it only to a replica inside scope and never falls back: with none ready there the node refuses the connection, and shc cluster fabric vips on that node says why with X503289VIPSCP. scope is node, the default, for the dialling node’s own replicas, location for the ones at its exact location leaf, or a location path such as hetzner/fsn1 or fsn1, read the way --scale reads a location: the replicas on nodes at that place or below it, whichever node dials. A path that names no location, or more than one, holds no replica, and the service selector refuses everywhere. scope goes with route: local only. A field other than these three, a route other than these three, or a scope that is not a lowercase path is refused X400454ALSDCL.
A service selector’s name is a lowercase DNS label. It may be a group’s name, which is how postgres above follows its primary, and a socket named after the group is then reached through it (Groups: service selectors). It may not be the name of a service, of a replica such as a member’s pod, or of another service selector. A replica answers through the service it is named for, so in a group name each member’s main service <group>-{{ m.n }}.
A name that is not a DNS label, a value that is not a selector, an empty selector, one that names a place (@edge, @( )), one that reads location or node, or a count other than :1 is refused X400454ALSDCL by the lint. The render refuses X400454ALSDCL a name a service or a replica has, and a bare count behind a compose label.
A service selector lives in the app only. No CLI flag sets one and no deployfile key holds one. To move one at deploy time, the app reads a var, app: side={{ active }}, and shc update <deployment> --var active=green flips it. The old key x-shc-aliases is refused for new input with the hint “did you mean x-shc-service-selectors”. A deployment installed from a package that still carries it re-renders from its recorded package unchanged.
At render the key is kept, in compose.yaml and in every replica project, and the stored spec carries the service selectors. Each gets a VIP of its own, and ce modules/vip builds its backends from the replicas’ labels on every node. A live label a service selector reads moves the routing as soon as two runs in a row agree on its new value. It moves only where new connections go: a TCP connection already sent to a replica goes on while that replica runs and passes its health check, whatever its labels say now, and ends when the replica stops or fails. A database that steps down refuses writes on the connections it still holds, and its clients reconnect to the new primary. shc status -s <deployment> lists each service selector with its selector as written, its route when it is not nearest, and the replicas it points at, and why it has no backend when it has none. -o json carries the same.
In shc.yaml: service_selectors at the top level. The old aliases key is refused.
x-shc-primary
Section titled “x-shc-primary”The app’s front door: the service a bare --expose <hostname> or --expose <port> goes to. true takes the first TCP port the service declares, reading expose: before ports:. A port number pins that port. false says the same as leaving the key off. Unmarked, the front door is the first service the file lists. An app has one front door hostname, so at most one service declares it, and other services attach paths under it with x-shc-path.
services: keycloak: image: quay.io/keycloak/keycloak:26.0 expose: ["8080", "8443"] x-shc-primary: 8080A quoted port, a fraction or a number outside 1 to 65535 is refused X400333XSHVAL. Two services that declare it are refused X400938HSTPRM, naming both. A pinned port the service does not declare, or a service with no TCP port, is refused X400939HSTPRP.
At render the key is kept. The election reads it on the template and again on the rendered compose.yaml (ce modules/app/primary_ingress.go). It writes no route by itself. --expose does, as a Traefik file route in ingress-<tenant>_<environment>_<stack>.yaml in the cluster’s Traefik section, with its router named after the deployment’s project, plus _<n> when the deployment has several routes. App definition has the full rules.
A hostname exposed bare follows this key. Every install and every update resolves it again, so a plain shc update after the key moved to another service moves the hostname there. A hostname exposed with a target (--expose <hostname>=<service>:<port>) is pinned and does not move (ce modules/app/host_spec.go MergeHostSpecs).
In shc.yaml: primary on the service.
x-shc-path
Section titled “x-shc-path”A path under the front door’s hostname that another service serves, such as nextcloud’s /push or windmill’s /ws. The value is an absolute URL path, not /, with no backtick, ?, #, ! or control character. The service needs a TCP port, and another service must declare x-shc-primary: a path attaches only under the front door.
services: nextcloud: image: nextcloud:30 expose: ["80"] x-shc-primary: true notify-push: image: ghcr.io/example/notify-push:1.0 expose: ["7867"] x-shc-path: /push x-shc-path-strip: trueA value outside those rules is refused X400333XSHVAL by the lint and X400940HSTSEC by the route election, whichever reads it first. A file with no primary, a service that declares both markers, or a service with no TCP port is refused X400940HSTSEC. Two services on one path are refused X400941HSTSCL.
At render the key is kept. A hostname exposed at the root of the front door, bare (--expose <hostname>) or pinned to the front door’s own service and port (--expose <hostname>=nextcloud:80), adds a route for each declared path beside the front door’s, Host(<hostname>) && PathPrefix(<path>) to the service’s first TCP port, in the same route file. A path-mounted spec (--expose h/cloud) or one pinned to another service adds none, and a declared route never replaces a route the operator exposed on that hostname and path. A service the render drops behind an {% if %} has its route skipped and logged X200995HSTSKP, and the route comes back with the first render that has the service again (ce modules/app/secondary_ingress.go).
Every render builds these routes again from the definition, under each hostname that serves the front door at its root. A plain shc update serves a path the definition gained and withdraws one it dropped. A declared path is not the operator’s to remove: --expose '<hostname>/push!' matches nothing and is reported X200970RMVNOP. It goes when the definition drops it, when its hostname is removed or pinned to another service, or when the operator exposes that path to a service of their own.
In shc.yaml: path on the service.
x-shc-path-strip
Section titled “x-shc-path-strip”true makes the edge strip the declared path before it dials the service, for a service that serves at its own root, such as nextcloud’s notify_push. Absent or false, the service gets the path the client sent: the app owns its path. It needs x-shc-path beside it. Alone it is refused X400940HSTSEC, and a value other than true or false is refused X400333XSHVAL.
At render the key is kept. The route gets a Traefik stripPrefix middleware named <router>_strip, chained last, and every router of that route that dials the service uses it (ce modules/app/inject_traefik.go).
In shc.yaml: path_strip on the service.
x-shc-upstream-tls
Section titled “x-shc-upstream-tls”A port the service serves over TLS only, such as a search engine’s REST API with its own certificate. Without it the edge dials every route as plain HTTP, and a TLS-only port answers that with a reset or a 400. port is the container port, a whole number from 1 to 65535. ca is the PEM text of the certificate authority the service’s certificate chains to, one or more certificates and nothing else. server_name is the DNS name that certificate is issued for. All three are required.
services: search: image: ghcr.io/example/search:2.1 expose: ["9200"] x-shc-upstream-tls: port: 9200 server_name: search.internal ca: | -----BEGIN CERTIFICATE----- MIIB... -----END CERTIFICATE-----The edge trusts that CA alone for the hop and checks the name; there is no switch that skips the check. Write the values literally: the reconcile sweep reads them from the app’s template before its variables render, so an install whose rendered declaration differs from its template’s, such as a ca that comes from a variable, is refused X400333XSHVAL. A whole service behind an {% if %} is fine: when the render leaves it out it has no route, so nothing is compared. A missing field, a port outside the range or one the service doesn’t list under expose or ports, an empty ca or one that holds anything but parseable certificates (a private key included), or a server_name that is not a DNS name is refused X400333XSHVAL, and another field X400332XSHFLD. A refusal never prints the PEM back.
At render the key is kept. Every route to that service on that port dials https:// through a Traefik serversTransport named <router>_tls, which holds the CA as its rootCAs and the name as its serverName, and the routers that share the route’s service use it too. Routes to the service’s other ports, and to other services, stay plain HTTP. The install render and the 60s sweep read the same declaration, so the route renders the same from minute zero (ce modules/app/upstream_tls.go, inject_traefik.go).
In shc.yaml: upstream_tls on the service.
x-shc-volumes
Section titled “x-shc-volumes”Top level. Asks for a provisioned block volume for a named volume, one entry per volume: size is bytes or a quantity with a suffix (Ki, Mi, Gi, Ti, K, M, G, T), and access is rwo, the default, or rox, read-only on several nodes.
services: db: image: postgres:17 volumes: - pgdata:/var/lib/postgresql/datax-shc-volumes: pgdata: size: 20Gi access: rwoA field other than size and access is refused X400332XSHFLD. A block or an entry that is not a mapping, or a size that reads as nothing, is refused X400333XSHVAL. At the volume step an access that is not a string is refused X400337VOLDCL, and an access mode other than rwo or rox, rwx included, X400328VOLACC. Durability is declared in backup.yaml, never here.
At render the key is kept in compose.yaml; each replica project keeps only the entries of the volumes it mounts. On a node with a volume provider the named volume is provisioned on block storage and bound from its mountpoint. With none, it stays the ordinary bind under the deployment’s mounts/ directory (ce core/volume/binding.go, What SHC does to your compose file). The deployment’s record keeps which backing each mount got.
In shc.yaml: size and access on the named volume’s mount.
x-shc-vault
Section titled “x-shc-vault”Secret level, and the only source a compose secret may name: a ref+vault:// reference, resolved through the same vault as the app’s variables.
services: db: image: postgres:17 secrets: - db_passwordsecrets: db_password: x-shc-vault: ref+vault://db_password?autogenA value that is not a ref+vault:// string is refused X400333XSHVAL. A secret with any key beside it other than name, such as file or environment, is refused X400942SECSRC, and a secret name that is not one path element is refused X400945SECNAM.
At render the key is kept, and the render adds file: pointing at the value it wrote into the node’s RAM-backed runtime directory. The value itself is never written into a compose file (ce modules/app/compose_secrets.go). Each replica project names its replica’s own copy, under .replicas/<pod>-r<n>/ in the deployment’s RAM directory. A service that mounts the secret starts again when shc update runs after its value moved in the vault.
In shc.yaml: vault on the secret.
x-shc-reach
Section titled “x-shc-reach”published on a long-form ports: entry says the port is a listener only a publication reaches, such as a KDC on 88. Without it a declared port opens to every deployment of the tenant, and a shared provider’s to every tenant. With it, nothing in the fabric reaches the port: the deployment’s own --expose (or shc_stack_ports) publishes it, and the policy drops any flow to it that no publication took, on TCP and UDP alike. The entry needs no published: or mode:, and a plain publish of it is allowed. Any other value is refused X400333XSHVAL, and the key anywhere but a ports entry is refused X400331XSHLVL.
At render the entry is removed, so the pin never declares the port, and each mapping that publishes it is marked published-only on the deployment’s published ports (ce modules/app/port_mappings.go, modules/fabric/policy).
Keys SHC writes
Section titled “Keys SHC writes”These keys are in the registry so the lint can name them. SHC writes the first four into the render itself and refuses each in an authored file, X400333XSHVAL, because whatever was written there would be overwritten. x-shc-http-ui is written by SHC’s importers; the lint accepts it in an authored file, and nothing at install reads it.
| Key | Level | Fields | Written by | Read by |
|---|---|---|---|---|
x-shc-quota | service | cpu, cpu_reservation_authored, cpu_source, memory, memory_reservation_authored, memory_source | the render’s quota step | the service rows and the next render |
x-shc-restart | service | a restart policy | the render’s restart step | the service rows and the dependent recycle |
x-shc-definitions | top level | volumes, networks | the volume, network and replica steps | the node that starts a replica |
x-shc-truststores | top level | a trust store per file name | the render’s CA trust step | the node that starts a replica |
x-shc-http-ui | service | true or false | importers | the import gate |
x-shc-quota
Section titled “x-shc-quota”A service’s resolved CPU and memory quota and the tier each came from. cpu and memory are the figures. cpu_source and memory_source name the tier: override for --cpu-quota or --memory-quota, config for the scoped deploy.cpu_quota or deploy.memory_quota knobs, limit for the app’s deploy.resources.limits, and reservation for its reservations when it states no limit. cpu_reservation_authored and memory_reservation_authored say whether the app wrote the reservation or the render derived it.
ApplyResourceQuotas (ce modules/app/resource_quota.go) writes it on every service that resolves a quota on either axis and leaves a service with none untouched. ParseComposeServices (ce modules/app/services_writer.go) reads it into the service rows at install, at restore and for status, and the next render reads it back so a re-render keeps the tier. It stays in compose.yaml and every replica project. Set the figure with --cpu-quota or --memory-quota, the scoped knobs, or deploy.resources (The resource model).
x-shc-restart
Section titled “x-shc-restart”The restart policy the app stated, recorded when the render takes the runtime’s away. Every service renders restart: "no", because a runtime that restarts containers at boot brings them back before the node knows it still owns them. The policy goes to the container label shc.restart.policy, which the node agent reads, and to this key, which ParseComposeServices and the dependent recycle read in place of restart: (ce modules/app/restart_default.go, dependent_recycle.go). No policy means on-failure, with the label shc.restart.defaulted: a clean exit the service makes on its own completes it, and one the node’s shutdown made is brought back at boot. It stays in compose.yaml and every replica project. State the policy with restart:.
x-shc-definitions
Section titled “x-shc-definitions”The volumes, networks and staged configs a node creates before it starts a replica. The replica split writes it into each replica’s sealed document (ce core/pod/project.go): volumes and networks from the app’s top-level volumes: and networks:, configs for each config the replica binds as a staged file, and volume_prep for the owner, mode and seed of each mount. The deployment’s compose.yaml carries it too when the render pinned networks for the deployment or a mount needs preparing, with networks and volume_prep (ce modules/app/deployment_networks.go PinDeploymentNetworks, install_runner.go). The node’s replica runner reads it (ce modules/pods/replica.go). The registry names only volumes and networks as its fields; it refuses the key whole, so the other two need no entry. shc inspect leaves it out of what it prints (ce modules/stack/render_redact.go).
x-shc-truststores
Section titled “x-shc-truststores”Java trust stores for the replicas, one entry per file: the name is the store’s file name, shc-ca-truststore-<digest>.p12, and the value its bytes in base64. On a cluster that runs replica projects, when the edge’s certificate comes from a CA a stock trust store does not hold and a service with a JVM image dials one of the cluster’s own HTTPS hostnames, the render builds a store from the image’s own cacerts plus the edge’s anchors and writes it here (ce modules/app/replica_trust.go storeReplicaTrust, jvm_ca_trust.go). Every replica project carries it. The node reads it before it starts a replica and writes each store into its platform mount directory, where the service’s JAVA_TOOL_OPTIONS points (StageReplicaTrust). On a cluster whose edge uses a public CA it is absent.
x-shc-http-ui
Section titled “x-shc-http-ui”Marks the service that serves an app’s web UI. SHC’s importers write it while they turn another platform’s app into compose, from umbrel’s app_proxy target, casaos’s x-casaos scheme and the like (ce modules/adapter/adapters), and the import gate refuses an app with more than one, ADAPTER_REJECT_MULTIPLE_HTTP_UI (ce modules/adapter/gate.go). It is not refused in an authored file, because the compose importer reads an operator’s file into the same shape. The lint checks only that it is true or false (X400333XSHVAL). Nothing at install reads it, and the rendered files keep it as written.
Not directives
Section titled “Not directives”A top-level key that starts with x-shc-refused is a catalogue idiom: it sits inside an {% if %}, and its value names a variable that does not exist, so the render stops with X400998TPLUND and the variable’s name is the message (apps/enterprise/defectdojo/compose.yaml). The lint never sees one, because the render has stopped first.
Importers keep x-shc-<platform>-* names, such as x-shc-casaos-compose-path or x-shc-unraid-template, on an app while they read it. Those live in the importer’s memory and never reach a compose file.
An SHC health probe is not a directive either. It is a word in compose’s own healthcheck.test, SHC-HTTP or SHC-TCP, and the render turns it into shc.probe.* labels and a disabled healthcheck (Health probes).
There is no x-shc-groups and no x-shc-member. A group is the {% members %} block (Groups), and either key is refused X400330XSHUNK.
There is no x-shc-lifecycle either. Run-once work is a start job with after: and before: (Lifecycle hooks), and the key is refused X400330XSHUNK.
There is no x-shc-disruption. How much of a deployment a drain may take down is the operator’s call, not the app’s: the deploy.disruption config key, rolling or never, set with shc update <deployment> -c deploy.disruption=never (config keys). The key is refused X400330XSHUNK, and shc.yaml has no disruption field.
The page is checked by TestTheXShcDirectivesPageListsEveryRegistryKey and TestTheXShcDirectivesPageSaysWhatTheRenderDoes in shc tests/_ce/modules/app/x_shc_directives_page_test.go: every key in xshcRegistry is a row with its level and fields, a key SHC writes sits in the second table, and each directive an app writes goes through the render steps that read or rewrite x-shc keys, which must keep or remove it and stamp the labels its row names (SHC-2455).