Pular para o conteúdo
Português (BR)

ConfigKeys

Este conteúdo não está disponível em sua língua ainda.

const ConfigKeys: object

Defined in: src/config/ConfigKeys.ts:27

Single source of truth for the framework’s HOCON config-key paths.

Every key the framework ever reads from Config.get(...) / Config.hasPath(...) should be reachable from this const-tree. Two motivations:

  1. Typo-safety: a string literal like 'actor-ts.io.broker.mqqt' (oops — three Q’s) is a silent runtime null at a config-lookup site. ConfigKeys.io.broker.mqtt.root is a typed reference — IDE autocomplete + TypeScript catch typos before they ship.

  2. Discoverability: a new contributor can scan this file to see every key the framework recognises, without grepping the whole codebase.

Convention: every leaf is the full dotted path as a string-literal type. Group structure mirrors the dotted hierarchy.

Migration policy: existing string literals are migrated in-place one site at a time. The tree’s runtime values are the SAME strings the codebase already uses — no behavioural change, just better compile-time safety.

readonly actor: object

System-wide actor defaults — actor-ts.actor.*.

The two leaves are not the same kind of knob: throughput is per-actor message-loop tuning, ask-timeout the caller-side deadline ActorRef.ask arms when nobody names one (#863). What puts them in one block is where they are answered — both are resolved once in the ActorSystem constructor and layered under an explicit argument, because neither a cell nor a ref reads config for itself. throughput has one layer between the two: the deployment entry matching the actor’s path (#868), compiled once per system as well.

Full dotted leaves rather than an actor block root, for the reason spelled out under mailbox below: with no root above them, NoDeadConfigKeys has to find each leaf here by its exact path to count it reachable.

readonly askTimeout: "actor-ts.actor.ask-timeout" = 'actor-ts.actor.ask-timeout'

readonly throughput: "actor-ts.actor.throughput" = 'actor-ts.actor.throughput'

readonly backoffSupervisor: object

BackoffSupervisor defaults — actor-ts.backoff-supervisor.*. Read once per supervisor, in its preStart, and layered under the explicit BackoffSupervisorOptions of that supervisor.

Top-level and a sibling of actor-ts.circuit-breaker rather than nested under an actor-ts.pattern.* umbrella: actor-ts.worker-cluster is the shape a block named after the options type it feeds already takes, and an umbrella nobody asked for would put the directory layout of src/ into the key an operator types.

Every leaf is spelled out rather than covered by a block root (#875): a root alone satisfies the NoDeadConfigKeys reachability check for everything beneath it, a misspelt leaf included.

readonly drainGrace: "actor-ts.backoff-supervisor.drain-grace" = 'actor-ts.backoff-supervisor.drain-grace'

auto (min(50ms, min-backoff), resolved per supervisor) | a duration.

readonly forward: "actor-ts.backoff-supervisor.forward" = 'actor-ts.backoff-supervisor.forward'

readonly forwardDuringGrace: "actor-ts.backoff-supervisor.forward-during-grace" = 'actor-ts.backoff-supervisor.forward-during-grace'

readonly maxBackoff: "actor-ts.backoff-supervisor.max-backoff" = 'actor-ts.backoff-supervisor.max-backoff'

readonly maxStashSize: "actor-ts.backoff-supervisor.max-stash-size" = 'actor-ts.backoff-supervisor.max-stash-size'

readonly minBackoff: "actor-ts.backoff-supervisor.min-backoff" = 'actor-ts.backoff-supervisor.min-backoff'

readonly randomFactor: "actor-ts.backoff-supervisor.random-factor" = 'actor-ts.backoff-supervisor.random-factor'

readonly resetCounter: "actor-ts.backoff-supervisor.reset-counter" = 'actor-ts.backoff-supervisor.reset-counter'

never | after-min-stable | a duration for the after-time variant.

readonly triggerOn: "actor-ts.backoff-supervisor.trigger-on" = 'actor-ts.backoff-supervisor.trigger-on'

readonly cache: object

Cache plugin-ids — actor-ts.cache.*.

readonly inMemory: "actor-ts.cache.in-memory" = 'actor-ts.cache.in-memory'

readonly inMemoryOptions: object

The global in-memory block’s settings, as against inMemory above, which is its plugin id — the factory-map key, re-exported as IN_MEMORY_CACHE_PLUGIN_ID and pinned by its literal value in the cache suite. The two carry the same string and stay two entries because one is an identifier and the other is a config path: growing inMemory into an object to hold these would break every use of the id.

Declared leaf by leaf because this group is the global block’s InMemoryCacheKeys, the shape readInMemoryCacheOptionsFromConfig is handed. The identical leaves under actor-ts.cache.<name>.in-memory cannot be listed (the name is the application’s); inMemoryCacheKeysUnder (src/cache/InMemoryCacheOptions.ts) composes those from the same five suffixes. NoDeadConfigKeys gains nothing from the leaves: root makes any key under actor-ts.cache reachable, and each leaf is proven read by changing it and watching that reader’s answer (#1425).

readonly cleanupInterval: "actor-ts.cache.in-memory.cleanup-interval" = 'actor-ts.cache.in-memory.cleanup-interval'

readonly maxEntries: "actor-ts.cache.in-memory.max-entries" = 'actor-ts.cache.in-memory.max-entries'

readonly prefixQuotas: "actor-ts.cache.in-memory.prefix-quotas" = 'actor-ts.cache.in-memory.prefix-quotas'

Comment-only in reference.conf — unset means one undivided map.

readonly root: "actor-ts.cache.in-memory" = 'actor-ts.cache.in-memory'

readonly timeToIdle: "actor-ts.cache.in-memory.time-to-idle" = 'actor-ts.cache.in-memory.time-to-idle'

readonly timeToLive: "actor-ts.cache.in-memory.time-to-live" = 'actor-ts.cache.in-memory.time-to-live'

readonly memcached: "actor-ts.cache.memcached" = 'actor-ts.cache.memcached'

readonly memcachedOptions: object

The global Memcached block’s settings — see redisOptions.

readonly keyPrefix: "actor-ts.cache.memcached.key-prefix" = 'actor-ts.cache.memcached.key-prefix'

readonly password: "actor-ts.cache.memcached.password" = 'actor-ts.cache.memcached.password'

readonly root: "actor-ts.cache.memcached" = 'actor-ts.cache.memcached'

readonly servers: "actor-ts.cache.memcached.servers" = 'actor-ts.cache.memcached.servers'

readonly username: "actor-ts.cache.memcached.username" = 'actor-ts.cache.memcached.username'

readonly redis: "actor-ts.cache.redis" = 'actor-ts.cache.redis'

readonly redisOptions: object

The global Redis block’s settings, standing to redis above exactly as inMemoryOptions stands to inMemory: one is the plugin id the factory map is keyed by (and REDIS_CACHE_PLUGIN_ID re-exports), the other is a config path. Same string, two entries, for the same reason.

Leaf by leaf rather than a root alone, because this group is the global block’s RedisCacheKeys, the shape readRedisCacheOptionsFromConfig is handed. The identical leaves under actor-ts.cache.<name>.redis cannot be listed (the name is the application’s); redisCacheKeysUnder composes those from the same suffixes. NoDeadConfigKeys resolves anything under actor-ts.cache to the root entry for reachability, so the leaves add nothing there; each is proven read by changing it and watching the reader’s answer (#1425).

host and port are comment-only in reference.conf: url is mutually exclusive with them, and a published host would be set for every deployment and refuse every url. They are read all the same, which is what this entry records.

readonly db: "actor-ts.cache.redis.db" = 'actor-ts.cache.redis.db'

readonly host: "actor-ts.cache.redis.host" = 'actor-ts.cache.redis.host'

readonly keyPrefix: "actor-ts.cache.redis.key-prefix" = 'actor-ts.cache.redis.key-prefix'

readonly password: "actor-ts.cache.redis.password" = 'actor-ts.cache.redis.password'

readonly port: "actor-ts.cache.redis.port" = 'actor-ts.cache.redis.port'

readonly root: "actor-ts.cache.redis" = 'actor-ts.cache.redis'

readonly url: "actor-ts.cache.redis.url" = 'actor-ts.cache.redis.url'

readonly root: "actor-ts.cache" = 'actor-ts.cache'

The block every named cache hangs under. CacheExtension composes two per-name paths from it that cannot be static leaves because the name is the caller’s: <root>.<name>.plugin selects the backend and <root>.<name>.in-memory overrides that instance’s settings.

readonly circuitBreaker: object

Named circuit breakers — actor-ts.circuit-breaker.*. Read by CircuitBreakerExtension.breaker(id), which layers <root>.<id>.* over <root>.default.* over the built-in floor, and the caller’s explicit options over all three.

default is reserved: it is the defaults block AND the id breaker() resolves with no argument, which is the same thing twice rather than a collision. <root>.<id>.* cannot be declared here at all — the id is the application’s — which is what ConfigKeys.cache.root is for too.

Every leaf under default is spelled out rather than covered by a default root, so readCircuitBreakerOptionsFromConfig takes the defaults block through the same leaf set circuitBreakerKeysUnder builds for a per-id one (#864). NoDeadConfigKeys gains nothing from it: root already makes every key under actor-ts.circuit-breaker reachable, and each leaf is proven read by changing it and watching that reader’s answer (#1425).

readonly default: object

readonly backoffFactor: "actor-ts.circuit-breaker.default.backoff-factor" = 'actor-ts.circuit-breaker.default.backoff-factor'

readonly callTimeout: "actor-ts.circuit-breaker.default.call-timeout" = 'actor-ts.circuit-breaker.default.call-timeout'

Comment-only in reference.conf — omitting it is what disables the per-call timeout.

readonly ignoredErrorNames: "actor-ts.circuit-breaker.default.ignored-error-names" = 'actor-ts.circuit-breaker.default.ignored-error-names'

readonly maxFailures: "actor-ts.circuit-breaker.default.max-failures" = 'actor-ts.circuit-breaker.default.max-failures'

readonly maxResetTimeout: "actor-ts.circuit-breaker.default.max-reset-timeout" = 'actor-ts.circuit-breaker.default.max-reset-timeout'

readonly randomFactor: "actor-ts.circuit-breaker.default.random-factor" = 'actor-ts.circuit-breaker.default.random-factor'

readonly resetTimeout: "actor-ts.circuit-breaker.default.reset-timeout" = 'actor-ts.circuit-breaker.default.reset-timeout'

readonly root: "actor-ts.circuit-breaker" = 'actor-ts.circuit-breaker'

readonly cluster: object

Cluster membership defaults — actor-ts.cluster.*. Read once by Cluster.join, which layers them under the explicit ClusterOptions.

cluster.leader-election is absent because it no longer exists: the leader is always the lowest-addressed up-member, and a one-value selector was documenting a choice the framework does not offer.

readonly appVersion: "actor-ts.cluster.app-version" = 'actor-ts.cluster.app-version'

The application version this node states to its peers (#843) — an advisory, operator-facing label for the window of a rolling update in which old and new code share one cluster. Gossiped on the member record and printed by Member.toString and /cluster/members; nothing places, routes or downs on it.

Ships comment-only in reference.conf, the remote.tcp.advertised-host shape: a leaf that is always present could not mean “this node states no version”, and that meaning is what keeps a fleet that never set one from putting anything on the wire. Being leafless also keeps it from DocumentedDefaults, as it does role below; NoDeadConfigKeys sees it only because the reader registry introduces it at one value and changes it to a second, and the exact-object reader pins in ClusterConfigDefaults.test.ts are what bind the value.

readonly bootstrap: object

Stable-observation bootstrap and readiness — actor-ts.cluster.bootstrap.* (#148, #1355). The observation timings are read once per bootstrapCluster call with stableObservation enabled, layered under the explicit tuning; the readiness pair (await-ready, minimum-members) is read by every bootstrapCluster call and by Cluster.awaitReady / isReady; new-cluster-enabled and the discovery sub-block are read by every bootstrapCluster call, before the join (#860).

The election’s outcome (ClusterOptions.selfElection) is deliberately not configurable here: it differs per node by construction, and one shared value would either stop every node from starting or have all of them self-elect at once. await-ready ships comment-only in reference.conf for a related reason — a leaf that is always present could not express “unset”, and unset is what selects the grace-aware computed default (#1086).

readonly awaitReady: "actor-ts.cluster.bootstrap.await-ready" = 'actor-ts.cluster.bootstrap.await-ready'

readonly discovery: object

Which seed provider the bootstrap builds, and the service it asks about — actor-ts.cluster.bootstrap.discovery.* (#860). Read by every bootstrapCluster call, not only the stable-observation one, and layered under the discovery: option in code.

They live under bootstrap rather than under the top-level discovery group because they are properties of this join: which ladder a node climbs and whose members it is looking for. The per-provider settings a deployment tunes independently of that choice are the discovery group below.

readonly method: "actor-ts.cluster.bootstrap.discovery.method" = 'actor-ts.cluster.bootstrap.discovery.method'

readonly serviceName: "actor-ts.cluster.bootstrap.discovery.service-name" = 'actor-ts.cluster.bootstrap.discovery.service-name'

readonly maxWait: "actor-ts.cluster.bootstrap.max-wait" = 'actor-ts.cluster.bootstrap.max-wait'

readonly minimumMembers: "actor-ts.cluster.bootstrap.minimum-members" = 'actor-ts.cluster.bootstrap.minimum-members'

readonly newClusterEnabled: "actor-ts.cluster.bootstrap.new-cluster-enabled" = 'actor-ts.cluster.bootstrap.new-cluster-enabled'

Whether a bootstrapped node may form a new cluster when it finds nobody to join (#860). Published on, because a deployment’s first start has to found one; off is the setting for every start after it, and bootstrapCluster warns once per start while it is on.

readonly pollInterval: "actor-ts.cluster.bootstrap.poll-interval" = 'actor-ts.cluster.bootstrap.poll-interval'

readonly requiredContactPoints: "actor-ts.cluster.bootstrap.required-contact-points" = 'actor-ts.cluster.bootstrap.required-contact-points'

readonly selfElectionGrace: "actor-ts.cluster.bootstrap.self-election-grace" = 'actor-ts.cluster.bootstrap.self-election-grace'

readonly stableMargin: "actor-ts.cluster.bootstrap.stable-margin" = 'actor-ts.cluster.bootstrap.stable-margin'

readonly client: object

The outside-in ClusterClient and its cluster-side endpoint — actor-ts.cluster.client.* (#858).

The client half is read by readClusterClientOptionsFromConfig, which — alone among the framework’s config readers, and for the reason readWorkerClusterOptionsFromConfig states — loads the config itself: new ClusterClient(options) holds no ActorSystem, so there is no system.config above it. The receptionist sub-block is read by readClusterClientReceptionistOptionsFromConfig from the system the extension runs in, and never self-loads.

Nested here rather than folded into receptionist below, which is the discovery Receptionist (src/discovery/Receptionist.ts) — a different actor with a different protocol. One shared word is not a reason to give an operator one block whose halves are read by two unrelated readers.

contact-points ships comment-only in reference.conf, the remote.tcp.advertised-host shape: the list is per-deployment identity, and [] is refused by ClusterClientOptionsValidator rather than meaning “unset”. It is read all the same, which is what this entry records.

Full dotted leaves rather than a client root, for the reason failure-detector.phi above states: with no root above them, NoDeadConfigKeys has to find each leaf here by its exact path. What checks the values is ClusterClientConfigDefaults.test.ts, which pins each reader’s return value exactly.

client-identity, tls and logger are absent on purpose and stay that way: the first is the CSPRNG-drawn wire address a shared config value would defeat, the second is certificate material, and the third is a Logger instance. buffer-size and reconnect-timeout are absent because the mechanisms are — #689 owns both and adds them here.

readonly askTimeout: "actor-ts.cluster.client.ask-timeout" = 'actor-ts.cluster.client.ask-timeout'

readonly connectTimeout: "actor-ts.cluster.client.connect-timeout" = 'actor-ts.cluster.client.connect-timeout'

readonly contactPoints: "actor-ts.cluster.client.contact-points" = 'actor-ts.cluster.client.contact-points'

readonly receptionist: object

readonly askTimeout: "actor-ts.cluster.client.receptionist.ask-timeout" = 'actor-ts.cluster.client.receptionist.ask-timeout'

readonly systemName: "actor-ts.cluster.client.system-name" = 'actor-ts.cluster.client.system-name'

readonly configurationCompatibilityCheck: object

Cluster-wide configuration agreement — actor-ts.cluster.configuration-compatibility-check.* (#844). Read once by readClusterOptionsFromConfig; Cluster publishes the listed settings’ effective values on the gossip overlay and compares what peers publish back.

Full dotted leaves rather than a block root, for the reason failure-detector.phi below states: with no root above them, NoDeadConfigKeys has to find each leaf here by its exact path.

cluster.configurationCompatibilityCheck.checkedPaths

Section titled “cluster.configurationCompatibilityCheck.checkedPaths”

readonly checkedPaths: "actor-ts.cluster.configuration-compatibility-check.checked-paths" = 'actor-ts.cluster.configuration-compatibility-check.checked-paths'

cluster.configurationCompatibilityCheck.enforce

Section titled “cluster.configurationCompatibilityCheck.enforce”

readonly enforce: "actor-ts.cluster.configuration-compatibility-check.enforce" = 'actor-ts.cluster.configuration-compatibility-check.enforce'

readonly downSmallerIsland: "actor-ts.cluster.down-smaller-island" = 'actor-ts.cluster.down-smaller-island'

ClusterOptionsType.downSmallerIsland (#1176).

readonly failureDetector: object

Failure detection — actor-ts.cluster.failure-detector.* (#840).

implementation picks the algorithm; heartbeat-interval is shared by both and belongs to the cluster’s heartbeat loop rather than to either detector (#1142), which is why the phi sub-block does not repeat it. unreachable-after / down-after are the simple detector’s thresholds and mean nothing to the φ-accrual one, whose suspicion values live under phi.

Full dotted leaves under phi, not a bare block root: with no root above them, NoDeadConfigKeys has to find each leaf here by its exact path to count it reachable, where a root would cover all six and a misspelt seventh. Whether the reader reads them is the gate’s other half, which changes each leaf and watches the reader’s answer, whatever this file declares (#1425).

expected-response-after takes the word auto or a duration (#1451): auto follows heartbeat-interval — the same single source as above, resolved by the detector rather than copied into its block.

auto-down is the block’s one policy leaf (#1426): whether a down verdict removes the peer when no split-brain strategy is configured. It governs both detectors — φ reaches down too — so, like implementation, it is read flat into failureDetectorAutoDown rather than into the simple detector’s thresholds. On by default; off is the opt-out that parks the peer. A configured strategy decides every removal whatever this says.

readonly autoDown: "actor-ts.cluster.failure-detector.auto-down" = 'actor-ts.cluster.failure-detector.auto-down'

readonly downAfter: "actor-ts.cluster.failure-detector.down-after" = 'actor-ts.cluster.failure-detector.down-after'

readonly heartbeatInterval: "actor-ts.cluster.failure-detector.heartbeat-interval" = 'actor-ts.cluster.failure-detector.heartbeat-interval'

readonly implementation: "actor-ts.cluster.failure-detector.implementation" = 'actor-ts.cluster.failure-detector.implementation'

readonly phi: object

cluster.failureDetector.phi.acceptableHeartbeatPause

Section titled “cluster.failureDetector.phi.acceptableHeartbeatPause”

readonly acceptableHeartbeatPause: "actor-ts.cluster.failure-detector.phi.acceptable-heartbeat-pause" = 'actor-ts.cluster.failure-detector.phi.acceptable-heartbeat-pause'

readonly downThreshold: "actor-ts.cluster.failure-detector.phi.down-threshold" = 'actor-ts.cluster.failure-detector.phi.down-threshold'

cluster.failureDetector.phi.expectedResponseAfter

Section titled “cluster.failureDetector.phi.expectedResponseAfter”

readonly expectedResponseAfter: "actor-ts.cluster.failure-detector.phi.expected-response-after" = 'actor-ts.cluster.failure-detector.phi.expected-response-after'

readonly maxSampleSize: "actor-ts.cluster.failure-detector.phi.max-sample-size" = 'actor-ts.cluster.failure-detector.phi.max-sample-size'

cluster.failureDetector.phi.minStdDeviation

Section titled “cluster.failureDetector.phi.minStdDeviation”

readonly minStdDeviation: "actor-ts.cluster.failure-detector.phi.min-std-deviation" = 'actor-ts.cluster.failure-detector.phi.min-std-deviation'

cluster.failureDetector.phi.unreachableThreshold

Section titled “cluster.failureDetector.phi.unreachableThreshold”

readonly unreachableThreshold: "actor-ts.cluster.failure-detector.phi.unreachable-threshold" = 'actor-ts.cluster.failure-detector.phi.unreachable-threshold'

readonly unreachableAfter: "actor-ts.cluster.failure-detector.unreachable-after" = 'actor-ts.cluster.failure-detector.unreachable-after'

readonly gossipInterval: "actor-ts.cluster.gossip-interval" = 'actor-ts.cluster.gossip-interval'

readonly maxMembers: "actor-ts.cluster.max-members" = 'actor-ts.cluster.max-members'

The two membership caps (#138). They bound what unauthenticated gossip can make the local member map hold — maxFrameBytes bounds one frame, these bound what a sequence of well-formed frames accumulates. 0 disables either.

readonly maxTombstones: "actor-ts.cluster.max-tombstones" = 'actor-ts.cluster.max-tombstones'

readonly minimumMembersBeforeUp: "actor-ts.cluster.minimum-members-before-up" = 'actor-ts.cluster.minimum-members-before-up'

Members that must be present before anything is promoted to up (#837) — the leader’s promotions and a founder’s own self-election alike.

Not bootstrap.minimum-members, which sits one block down and is a wait predicate for awaitReady / isReady: that one counts up members and never changes a status, this one decides whether a status changes at all. The -before-up suffix is what keeps the two apart in an operator’s config file, and is the reason this key is not simply minimum-members.

readonly publishStatsInterval: "actor-ts.cluster.publish-stats-interval" = 'actor-ts.cluster.publish-stats-interval'

How often this node publishes a ClusterStatsPublished sample of its own membership view on system.eventStream (#842). 0 arms no timer, which is what every release before the key did.

Read by readClusterOptionsFromConfig into ClusterOptionsType.publishStatsIntervalMs; Cluster._start arms the timer only for a positive value.

Not actor-ts.devtools.stats-interval, which paces the DevTools dashboard’s own sampler over the websocket. Same figures, different channel and different audience — and neither forwards into the other, because one number with two periodic sources is how two views of a cluster start disagreeing about it.

readonly pubSub: object

DistributedPubSub mediator tuning — actor-ts.cluster.pub-sub.*. Read once per DistributedPubSub.start, which layers them under the explicit options. The three caps bound what one mediator can be made to hold; they are config rather than constants because the right value depends on the deployment’s subscriber-to-node ratio (#139, #857).

readonly gossipInterval: "actor-ts.cluster.pub-sub.gossip-interval" = 'actor-ts.cluster.pub-sub.gossip-interval'

readonly maxRemoteNodesPerTopic: "actor-ts.cluster.pub-sub.max-remote-nodes-per-topic" = 'actor-ts.cluster.pub-sub.max-remote-nodes-per-topic'

readonly maxSubscribersPerTopic: "actor-ts.cluster.pub-sub.max-subscribers-per-topic" = 'actor-ts.cluster.pub-sub.max-subscribers-per-topic'

readonly maxTopics: "actor-ts.cluster.pub-sub.max-topics" = 'actor-ts.cluster.pub-sub.max-topics'

cluster.pubSub.sendToDeadLettersWhenNoSubscribers

Section titled “cluster.pubSub.sendToDeadLettersWhenNoSubscribers”

readonly sendToDeadLettersWhenNoSubscribers: "actor-ts.cluster.pub-sub.send-to-dead-letters-when-no-subscribers" = 'actor-ts.cluster.pub-sub.send-to-dead-letters-when-no-subscribers'

readonly receptionist: object

Receptionist tuning — actor-ts.cluster.receptionist.*. Read once per ReceptionistExtension.start, which layers them under the explicit options (#137, #857).

readonly gossipInterval: "actor-ts.cluster.receptionist.gossip-interval" = 'actor-ts.cluster.receptionist.gossip-interval'

readonly maxSubscribersPerKey: "actor-ts.cluster.receptionist.max-subscribers-per-key" = 'actor-ts.cluster.receptionist.max-subscribers-per-key'

cluster.receptionist.maxSubscriptionsTotal

Section titled “cluster.receptionist.maxSubscriptionsTotal”

readonly maxSubscriptionsTotal: "actor-ts.cluster.receptionist.max-subscriptions-total" = 'actor-ts.cluster.receptionist.max-subscriptions-total'

readonly role: "actor-ts.cluster.role" = 'actor-ts.cluster.role'

Root of the per-role Up thresholds — actor-ts.cluster.role.<role>.minimum-members-before-up (#837).

A root rather than leaves, and unavoidably so: the role names belong to the deployment, so no full path can be written down here. ClusterOptions.ts composes the leaf from this root, exactly as redisCacheKeysUnder composes a per-name cache block’s.

Ships comment-only in reference.conf for the same reason, so DocumentedDefaults, which walks REFERENCE_CONF’s leaves, never sees it, and NoDeadConfigKeys does only because the reader registry introduces the root as one role’s block and changes its threshold. What checks this entry is ClusterConfigDefaults.test.ts, which reads a written-out role block back through readClusterOptionsFromConfig.

readonly roles: "actor-ts.cluster.roles" = 'actor-ts.cluster.roles'

The role tags this node carries (#836) — what shard regions, singletons, the per-role thresholds above and the role-filtered downing strategies place on.

The half of #836 that reverses nothing: no file ever gave a roles-specific reason to keep it out of HOCON, and sharding.role already lets a config file filter on a role, which is only usable if the same file can assign one.

readonly runCoordinatedShutdownWhenDown: "actor-ts.cluster.run-coordinated-shutdown-when-down" = 'actor-ts.cluster.run-coordinated-shutdown-when-down'

Whether a node whose own downing decision removes it runs the coordinated-shutdown pipeline after leaving, with ClusterDowningReason (#1456). Off by default; the trade between a downed node that keeps running and a wrong self-down that terminates one is on DEFAULT_RUN_COORDINATED_SHUTDOWN_WHEN_DOWN.

A direct child of the cluster block rather than of split-brain-resolver, because it is about what this node does once it is out, not about how a strategy picks a side — and down-all-when-unstable reaches it with no strategy’s verdict at all. Read by readClusterOptionsFromConfig into ClusterOptionsType.runCoordinatedShutdownWhenDown.

readonly seedNodes: "actor-ts.cluster.seed-nodes" = 'actor-ts.cluster.seed-nodes'

The peers this node announces itself to at start-up (#836).

In config despite being per-node identity, and the reason is that it is not per-node in the shape the project prescribes: Cluster removes this node’s own address before dialling, so a file naming the designated first node is correct on every node of the deployment — that node is left with an empty list and self-elects, everyone else dials it. What stays out is selfElection, whose shared value is not merely useless but unsafe; the ranking is in ClusterConfigDefaults’ own doc.

Read as a list and only as a list: a single ${?SEED_NODES} lands a string and getStringList refuses it. The per-entry substitution form is what works, and reference.conf spells it out beside the key.

readonly seedRetryInterval: "actor-ts.cluster.seed-retry-interval" = 'actor-ts.cluster.seed-retry-interval'

readonly shutdownAfterUnsuccessfulJoin: "actor-ts.cluster.shutdown-after-unsuccessful-join" = 'actor-ts.cluster.shutdown-after-unsuccessful-join'

How long a node may stay joining or weakly-up before it gives up the join (#1500). 0 sets no deadline, which is what every release before the key did. When it passes, the node asks whether anything can still promote it — the verdict the cold-start stall warning states — and only if nothing can does it warn, leave and run the coordinated-shutdown pipeline with ClusterJoinUnsuccessfulReason; otherwise it asks again every seed-retry-interval.

Its own key rather than a reuse of bootstrap.await-ready: that one budgets a single Cluster.bootstrap call and is sized to the election grace (#1086), while this one applies to every Cluster.join, bootstrapped or not, and is composed with it on that path. Read by readClusterOptionsFromConfig into ClusterOptionsType.shutdownAfterUnsuccessfulJoinMs.

readonly singleton: object

Cluster-singleton placement and tuning — actor-ts.cluster.singleton.* (#855). Read once per ClusterSingleton.start, which layers the block under the caller’s StartSingletonOptions, and once per ClusterSingleton.ref — the only channel a proxy-only node has, since ref() takes no options object at all.

Nested under cluster rather than top-level by the test distributedData states below, applied the other way round: that module is top-level because it ships from src/crdt/ and its options type carries no cluster field. The singleton fails both halves — it ships from src/cluster/singleton/, and ClusterSingletonManagerOptionsType carries a cluster field — so it nests, beside pub-sub and receptionist.

Full dotted leaves rather than a bare singleton root, for the reason failure-detector.phi above states: with no root above them, NoDeadConfigKeys has to find each leaf here by its exact path.

useLease gives each singleton a lease built from actor-ts.coordination.lease (#1454): refused at start while lease.backend = none, and outranked by an explicit withLease(…). Three of the keys #855 proposed stay absent on purpose: lease-name (the name is derived per singleton, and one written is refused), min-number-of-hand-over-retries (the wait is bounded by hand-over-timeout, and nothing counts attempts) and singleton-identification-interval (the proxy never polls — it subscribes to cluster events once). hand-over-retry-interval is refused in writing by SINGLETON_HAND_OVER_RETRY_INTERVAL_MS’s own JSDoc.

readonly acquireRetryInterval: "actor-ts.cluster.singleton.acquire-retry-interval" = 'actor-ts.cluster.singleton.acquire-retry-interval'

readonly bufferSize: "actor-ts.cluster.singleton.buffer-size" = 'actor-ts.cluster.singleton.buffer-size'

readonly handOverTimeout: "actor-ts.cluster.singleton.hand-over-timeout" = 'actor-ts.cluster.singleton.hand-over-timeout'

readonly maxHandOverStateBytes: "actor-ts.cluster.singleton.max-hand-over-state-bytes" = 'actor-ts.cluster.singleton.max-hand-over-state-bytes'

readonly restartOnTermination: "actor-ts.cluster.singleton.restart-on-termination" = 'actor-ts.cluster.singleton.restart-on-termination'

readonly role: "actor-ts.cluster.singleton.role" = 'actor-ts.cluster.singleton.role'

readonly useLease: "actor-ts.cluster.singleton.use-lease" = 'actor-ts.cluster.singleton.use-lease'

readonly splitBrainResolver: object

Split-brain resolution — actor-ts.cluster.split-brain-resolver.* (#838). active-strategy names which DowningProvider readDowningFromConfig (src/cluster/downing/DowningFromConfig.ts) builds; the per-strategy leaves are that strategy’s own options.

All five strategies are selectable. lease-majority arbitrates through a lease built from actor-ts.coordination.lease (#1454): the reader checks that block when the cluster starts — lease.backend = none refuses the strategy — and the lease itself is built at the first decision, because its owner is this node’s address and the provider exists before the address does. There is no lease-majority sub-block; one written is refused.

static-quorum.quorum-size and the two keep-referee leaves ship comment-only in reference.conf, so hasPath stays false until an operator sets one. Each is required or bounded and has no legal default: quorum-size = 0 is refused by StaticQuorumOptionsValidator and referee-address = "" by KeepRefereeOptionsValidator, so a shipped leaf could only be a value that stops the node from starting. They are still declared here, which is what makes setting one in an application.conf work — the remote.tcp.advertised-host shape.

Full dotted leaves rather than a split-brain-resolver root, for the reason failure-detector.phi above states: with no root above them, NoDeadConfigKeys has to find each leaf here by its exact path.

readonly activeStrategy: "actor-ts.cluster.split-brain-resolver.active-strategy" = 'actor-ts.cluster.split-brain-resolver.active-strategy'

cluster.splitBrainResolver.downAllWhenUnstable

Section titled “cluster.splitBrainResolver.downAllWhenUnstable”

readonly downAllWhenUnstable: "actor-ts.cluster.split-brain-resolver.down-all-when-unstable" = 'actor-ts.cluster.split-brain-resolver.down-all-when-unstable'

readonly keepMajority: object

cluster.splitBrainResolver.keepMajority.role

Section titled “cluster.splitBrainResolver.keepMajority.role”

readonly role: "actor-ts.cluster.split-brain-resolver.keep-majority.role" = 'actor-ts.cluster.split-brain-resolver.keep-majority.role'

readonly keepOldest: object

cluster.splitBrainResolver.keepOldest.downIfAlone

Section titled “cluster.splitBrainResolver.keepOldest.downIfAlone”

readonly downIfAlone: "actor-ts.cluster.split-brain-resolver.keep-oldest.down-if-alone" = 'actor-ts.cluster.split-brain-resolver.keep-oldest.down-if-alone'

cluster.splitBrainResolver.keepOldest.role

Section titled “cluster.splitBrainResolver.keepOldest.role”

readonly role: "actor-ts.cluster.split-brain-resolver.keep-oldest.role" = 'actor-ts.cluster.split-brain-resolver.keep-oldest.role'

readonly keepReferee: object

cluster.splitBrainResolver.keepReferee.downAllIfBelowQuorum

Section titled “cluster.splitBrainResolver.keepReferee.downAllIfBelowQuorum”

readonly downAllIfBelowQuorum: "actor-ts.cluster.split-brain-resolver.keep-referee.down-all-if-below-quorum" = 'actor-ts.cluster.split-brain-resolver.keep-referee.down-all-if-below-quorum'

Comment-only — absence is what “no extra quorum rule” has to look like.

cluster.splitBrainResolver.keepReferee.refereeAddress

Section titled “cluster.splitBrainResolver.keepReferee.refereeAddress”

readonly refereeAddress: "actor-ts.cluster.split-brain-resolver.keep-referee.referee-address" = 'actor-ts.cluster.split-brain-resolver.keep-referee.referee-address'

Comment-only in reference.conf — "" is refused by the validator.

readonly stableAfter: "actor-ts.cluster.split-brain-resolver.stable-after" = 'actor-ts.cluster.split-brain-resolver.stable-after'

The policy half of the block (#839) — when the resolver is asked, as against which one active-strategy above builds. Read by readSplitBrainResolverOptionsFromConfig (src/cluster/downing/SplitBrainResolverOptions.ts) into ClusterOptionsType.splitBrainResolver, and consumed by Cluster.evaluateDowning; no bundled strategy sees either value.

They configure the provider path only. With no provider there is no decision for a window to delay: the failure detector removes a down peer at failure-detector.down-after under the default failure-detector.auto-down = on, or parks it at unreachable when that is off (#1426), and putting a second window in front of that from this block would be two thresholds for one decision, under a name that says “resolver”.

readonly staticQuorum: object

cluster.splitBrainResolver.staticQuorum.quorumSize

Section titled “cluster.splitBrainResolver.staticQuorum.quorumSize”

readonly quorumSize: "actor-ts.cluster.split-brain-resolver.static-quorum.quorum-size" = 'actor-ts.cluster.split-brain-resolver.static-quorum.quorum-size'

Comment-only in reference.conf — 0 is refused by the validator.

cluster.splitBrainResolver.staticQuorum.role

Section titled “cluster.splitBrainResolver.staticQuorum.role”

readonly role: "actor-ts.cluster.split-brain-resolver.static-quorum.role" = 'actor-ts.cluster.split-brain-resolver.static-quorum.role'

readonly tombstone: object

Tombstone housekeeping — actor-ts.cluster.tombstone.* (#841). Grouped in HOCON because an operator tunes the three together; the matching ClusterOptions fields stay flat (tombstoneTtlMs, …), the same translation remote.tcp.host → host already makes.

readonly minRetention: "actor-ts.cluster.tombstone.min-retention" = 'actor-ts.cluster.tombstone.min-retention'

readonly pruneInterval: "actor-ts.cluster.tombstone.prune-interval" = 'actor-ts.cluster.tombstone.prune-interval'

readonly timeToLive: "actor-ts.cluster.tombstone.time-to-live" = 'actor-ts.cluster.tombstone.time-to-live'

readonly weaklyUpAfter: "actor-ts.cluster.weakly-up-after" = 'actor-ts.cluster.weakly-up-after'

Auto-promotion joining → weakly-up; 0 keeps it opt-in (#841).

readonly coordinatedShutdown: object

CoordinatedShutdown pipeline defaults — actor-ts.coordinated-shutdown.*.

Every leaf is read through readCoordinatedShutdownOptionsFromConfig, the registered reader: the extension’s constructor applies what it returns, and ActorSystem reads run-by-actor-system-terminate through it when the system is built, because a bare terminate() must not build the extension to ask (#1455). What it returns is no options triad — nothing in code hands the extension these settings, the reason DEFAULT_PHASE_TIMEOUT_MS gives in src/Constants.ts — only the shape the config layer reads into.

phases is a block root rather than a leaf, and it ships comment-only in reference.conf: its children are named after the operator’s phases, so there is no fixed set of leaves to publish, and an example one (phases.service-unbind.timeout = 5s) would freeze that example’s budget into every deployment’s effective config (#866).

readonly autoRegisterTasks: "actor-ts.coordinated-shutdown.auto-register-tasks" = 'actor-ts.coordinated-shutdown.auto-register-tasks'

readonly defaultPhaseTimeout: "actor-ts.coordinated-shutdown.default-phase-timeout" = 'actor-ts.coordinated-shutdown.default-phase-timeout'

readonly exitCode: "actor-ts.coordinated-shutdown.exit-code" = 'actor-ts.coordinated-shutdown.exit-code'

readonly exitProcess: "actor-ts.coordinated-shutdown.exit-process" = 'actor-ts.coordinated-shutdown.exit-process'

readonly phases: "actor-ts.coordinated-shutdown.phases" = 'actor-ts.coordinated-shutdown.phases'

coordinatedShutdown.runByActorSystemTerminate

Section titled “coordinatedShutdown.runByActorSystemTerminate”

readonly runByActorSystemTerminate: "actor-ts.coordinated-shutdown.run-by-actor-system-terminate" = 'actor-ts.coordinated-shutdown.run-by-actor-system-terminate'

readonly runByProcessSignals: "actor-ts.coordinated-shutdown.run-by-process-signals" = 'actor-ts.coordinated-shutdown.run-by-process-signals'

readonly terminateActorSystem: "actor-ts.coordinated-shutdown.terminate-actor-system" = 'actor-ts.coordinated-shutdown.terminate-actor-system'

readonly coordinatedStartup: object

The startup graph’s budgets — actor-ts.coordinated-startup.* (#1473), read by readCoordinatedStartupOptionsFromConfig and layered under what ActorSystemOptions.withCoordinatedStartup sets in code.

phases is a block root rather than a leaf and ships comment-only, for the reason the shutdown block’s does: its children are named after the phases a deployment retimes or adds, so there is no fixed set of leaves to publish. Its children are type-checked by the shutdown block’s own reader, so the two blocks accept exactly the same settings.

readonly defaultPhaseTimeout: "actor-ts.coordinated-startup.default-phase-timeout" = 'actor-ts.coordinated-startup.default-phase-timeout'

readonly phases: "actor-ts.coordinated-startup.phases" = 'actor-ts.coordinated-startup.phases'

readonly coordination: object

Lease coordination — actor-ts.coordination.* (#859, #1454).

Every leaf is spelled out rather than covered by a block root: with no root above them, NoDeadConfigKeys has to find each leaf here by its exact path, where a root would make any leaf under it reachable. The readers here are readLeaseOptionsFromConfig (src/coordination/LeaseOptions.ts), readKubernetesLeaseOptionsFromConfig (src/coordination/leases/KubernetesLeaseOptions.ts) and readLeaseBackendFromConfig (src/coordination/LeaseFromConfig.ts).

lease.backend names what the framework builds a lease with when a consumer’s switch asks for one — sharding.use-lease, cluster.singleton.use-lease, split-brain-resolver.active-strategy = lease-majority (#1454). none or kubernetes; in-memory is refused by name, because its store is per isolate and a configured one would gate nothing. A built lease’s name and owner have no key and are refused when written: the name is derived per consumer and the owner per node, and one value shared by a deployment could mean neither.

lease.ttl, lease.renewal-interval and lease.kubernetes.namespace deliberately ship no leaf in reference.conf, so hasPath stays false until an operator sets one. Each is a field the code either requires or derives: a shipped ttl would satisfy validateRequired for every lease in the process and make the #596 guard unreachable; a shipped renewal-interval would displace the computed default (a third of the TTL with a floor of 500 ms for Kubernetes and 100 ms in memory, capped at half the TTL), and 0 cannot stand in for “derive it” because the validator rejects it; a shipped namespace could only be "", which the validator rejects too, and would take away “read it from the Pod’s ServiceAccount mount”. They are still read here, which is what makes setting one in an application.conf work.

acquire-retries / acquire-retry-delay have no keys at all: the two backends ship different built-in defaults (3 / 100 ms for Kubernetes, 1 / 50 ms in memory) and a single leaf would silently unify them.

readonly lease: object

readonly backend: "actor-ts.coordination.lease.backend" = 'actor-ts.coordination.lease.backend'

readonly kubernetes: object

readonly caPath: "actor-ts.coordination.lease.kubernetes.ca-path" = 'actor-ts.coordination.lease.kubernetes.ca-path'

coordination.lease.kubernetes.leaseNameMaxLength

Section titled “coordination.lease.kubernetes.leaseNameMaxLength”

readonly leaseNameMaxLength: "actor-ts.coordination.lease.kubernetes.lease-name-max-length" = 'actor-ts.coordination.lease.kubernetes.lease-name-max-length'

readonly namespace: "actor-ts.coordination.lease.kubernetes.namespace" = 'actor-ts.coordination.lease.kubernetes.namespace'

coordination.lease.kubernetes.namespacePath

Section titled “coordination.lease.kubernetes.namespacePath”

readonly namespacePath: "actor-ts.coordination.lease.kubernetes.namespace-path" = 'actor-ts.coordination.lease.kubernetes.namespace-path'

coordination.lease.kubernetes.operationTimeout

Section titled “coordination.lease.kubernetes.operationTimeout”

readonly operationTimeout: "actor-ts.coordination.lease.kubernetes.operation-timeout" = 'actor-ts.coordination.lease.kubernetes.operation-timeout'

readonly tokenPath: "actor-ts.coordination.lease.kubernetes.token-path" = 'actor-ts.coordination.lease.kubernetes.token-path'

coordination.lease.kubernetes.tokenReloadInterval

Section titled “coordination.lease.kubernetes.tokenReloadInterval”

readonly tokenReloadInterval: "actor-ts.coordination.lease.kubernetes.token-reload-interval" = 'actor-ts.coordination.lease.kubernetes.token-reload-interval'

readonly renewalInterval: "actor-ts.coordination.lease.renewal-interval" = 'actor-ts.coordination.lease.renewal-interval'

readonly ttl: "actor-ts.coordination.lease.ttl" = 'actor-ts.coordination.lease.ttl'

readonly deadLetters: object

Dead-letter queue — actor-ts.dead-letters.*. Read once, in the ActorSystem constructor, before any actor exists: a queue installed later would have missed whatever died in between.

A top-level block rather than a leaf under actor-ts.diagnostics.* because capture is not a diagnostic switch — persistent makes it a durability guarantee with a journal behind it. Anything that suppresses or samples the dead-letter stream (#1179) belongs under diagnostics and must gate downstream of this capture, or the queue’s completeness claim is silently false.

This namespace is settled, and here is the reasoning it was missing. It shipped under #433 while #1179 and #867 were both open, which left it looking like a decision taken rather than made. Re-examined against what those two issues actually propose, they are not rival homes for these keys and they are not even each other’s:

  • #1179 wants a per-recipient token bucket over the publish path, and sketches it under actor-ts.diagnostics.*.
  • #867 wanted dead-letter logging toggles, and sketched them at the root — log-dead-letters, log-dead-letters-during-shutdown, log-dead-letters-suspend-duration — beside actor-ts.debug.*. That sketch is superseded: #1000 shipped those three under diagnostics below, because Reference.ts has fourteen root blocks and no root-level leaf at all, and because the switch that turns a default-on log line off cannot ship after the log line does.

Neither asks for the retention keys to move, and there is no single alternative block they could move into. The line that matters is the reader: everything here is read by DeadLetterQueue and decides what is retained; everything those two want is read on the publish side by DeadLetterRef and decides how loudly a letter is announced. Merging them would give one block two readers in two subsystems, and would make a suppression knob look like it gates capture — which the code deliberately prevents by capturing before publishing. Splitting by reader also keeps the safety property checkable in one place instead of by convention.

If it is ever renamed anyway, the cost is 21 files and not four: this file, Reference.ts, DeadLetterQueueOptions.ts, ActorSystem.ts, five EN docs pages with their five DE twins, and seven test files. Only the two reference-conf.mdx pages announce themselves, being byte-pinned by tests/unit/config/ReferenceConfDocs.test.ts.

readonly maxEntries: "actor-ts.dead-letters.max-entries" = 'actor-ts.dead-letters.max-entries'

readonly maxReplays: "actor-ts.dead-letters.max-replays" = 'actor-ts.dead-letters.max-replays'

readonly persistenceId: "actor-ts.dead-letters.persistence-id" = 'actor-ts.dead-letters.persistence-id'

readonly retention: "actor-ts.dead-letters.retention" = 'actor-ts.dead-letters.retention'

readonly store: "actor-ts.dead-letters.store" = 'actor-ts.dead-letters.store'

readonly deployment: object

Per-path deployment entries — actor-ts.deployment."<path pattern>" (#868): throughput, mailbox-capacity and mailbox-overflow for the actors whose path a key matches, layered between the spawn site and the system-wide actor.throughput / mailbox.default.

A block root plus the three leaf names relative to one entry, not full paths: the keys under the root are the application’s actor paths, so there is no fixed set of leaves to list, and a path holds / and may hold ., which Config.hasPath splits on. readDeploymentFromConfig reads the root as an object and each entry through a Config of its own — the shape the coordinated-shutdown phases and the in-memory cache’s prefix-quotas are read in.

Comment-only in reference.conf: a shipped entry would be a live default in every deployment’s effective config, and a capacity there would bring back the bound #1148 removed. So the leaf-driven guards see nothing of it by themselves — DocumentedDefaults pins published leaves only, and NoDeadConfigKeys perturbs this block only because the reader registry introduces it as an object. The proof that it is wired is behavioural: DeploymentConfigDefaults.test.ts binds the reader, and DeploymentBlock.test.ts the cell that applies what it read.

readonly entry: object

readonly mailboxCapacity: "mailbox-capacity" = 'mailbox-capacity'

readonly mailboxOverflow: "mailbox-overflow" = 'mailbox-overflow'

readonly throughput: "throughput" = 'throughput'

readonly root: "actor-ts.deployment" = 'actor-ts.deployment'

readonly devtools: object

DevTools attachment defaults — actor-ts.devtools.*.

The block does not start DevTools: nothing in ActorSystem constructs the extension, and DevTools.attach(system) is always a code call. It fills in what that call leaves unset, and is read once per attach or mount by readDevToolsOptionsFromConfig.

Every leaf is declared individually, panels included, rather than as a block root read whole. NoDeadConfigKeys resolves a leaf under a root to that root’s accessor for reachability, so a root-only entry would vouch for leaves no accessor names; declared, each has to be named here. That each is read the gate proves by changing it and watching readDevToolsOptionsFromConfig’s answer, however that reader is written.

auth, ipAllowlist, backend, cluster and replayFolds have no leaf because HOCON cannot express a function or a live object. allowUngatedMount and allowMessageSending have none by decision: one states a fact about the code that binds mount()’s routes rather than about a deployment, the other grants a browser write access into the running system (#881).

readonly allowedOrigins: "actor-ts.devtools.allowed-origins" = 'actor-ts.devtools.allowed-origins'

readonly allowRemote: "actor-ts.devtools.allow-remote" = 'actor-ts.devtools.allow-remote'

readonly capturePayloads: "actor-ts.devtools.capture-payloads" = 'actor-ts.devtools.capture-payloads'

readonly eventBufferCapacity: "actor-ts.devtools.event-buffer-capacity" = 'actor-ts.devtools.event-buffer-capacity'

readonly eventFlushInterval: "actor-ts.devtools.event-flush-interval" = 'actor-ts.devtools.event-flush-interval'

readonly host: "actor-ts.devtools.host" = 'actor-ts.devtools.host'

readonly mailboxSampleInterval: "actor-ts.devtools.mailbox-sample-interval" = 'actor-ts.devtools.mailbox-sample-interval'

readonly mailboxSampleLimit: "actor-ts.devtools.mailbox-sample-limit" = 'actor-ts.devtools.mailbox-sample-limit'

readonly panels: object

Per-panel switches; a panel is disabled only by an explicit false.

readonly actors: "actor-ts.devtools.panels.actors" = 'actor-ts.devtools.panels.actors'

readonly cluster: "actor-ts.devtools.panels.cluster" = 'actor-ts.devtools.panels.cluster'

readonly config: "actor-ts.devtools.panels.config" = 'actor-ts.devtools.panels.config'

readonly deadLetters: "actor-ts.devtools.panels.dead-letters" = 'actor-ts.devtools.panels.dead-letters'

readonly eventStream: "actor-ts.devtools.panels.event-stream" = 'actor-ts.devtools.panels.event-stream'

readonly explain: "actor-ts.devtools.panels.explain" = 'actor-ts.devtools.panels.explain'

readonly profiler: "actor-ts.devtools.panels.profiler" = 'actor-ts.devtools.panels.profiler'

readonly send: "actor-ts.devtools.panels.send" = 'actor-ts.devtools.panels.send'

readonly timeTravel: "actor-ts.devtools.panels.time-travel" = 'actor-ts.devtools.panels.time-travel'

readonly tracing: "actor-ts.devtools.panels.tracing" = 'actor-ts.devtools.panels.tracing'

readonly port: "actor-ts.devtools.port" = 'actor-ts.devtools.port'

readonly replayAutoCapture: "actor-ts.devtools.replay-auto-capture" = 'actor-ts.devtools.replay-auto-capture'

readonly serveUi: "actor-ts.devtools.serve-ui" = 'actor-ts.devtools.serve-ui'

readonly spanBufferCapacity: "actor-ts.devtools.span-buffer-capacity" = 'actor-ts.devtools.span-buffer-capacity'

readonly spanFlushInterval: "actor-ts.devtools.span-flush-interval" = 'actor-ts.devtools.span-flush-interval'

readonly statsInterval: "actor-ts.devtools.stats-interval" = 'actor-ts.devtools.stats-interval'

readonly diagnostics: object

What the runtime says about itself — actor-ts.diagnostics.*.

Read once, in the ActorSystem constructor, and handed to DeadLetterRef — the announce side of a dead letter, as against the capture side that deadLetters above configures. That split is the settled namespace argument recorded there: retention is read by DeadLetterQueue, loudness by DeadLetterRef, and merging them would make a suppression knob look like it gates capture.

Full dotted leaves rather than a block root on purpose. NoDeadConfigKeys asks two things of every leaf reference.conf ships: that this tree reaches it, and that changing it on its own changes what some registered reader answers (#1425). Only the first looks at this file, and a root would satisfy it for every leaf beneath it, a misspelt one included; with no root above them, each of these leaves has to be named here exactly. The second watches the readers’ answers rather than this file’s layout, so no layout of this group can carry a leaf nothing reads through it.

#867 extended it with log-config-on-start and the three debug.* switches; #1179’s per-recipient suppression lands here too.

The log-* / debug.* split is by level, and that is the whole reason for the nesting. Everything named log-… is emitted at info or warn and appears in a default deployment once it is switched on. Everything under debug is emitted at debug and therefore needs actor-ts.logger.level = debug as well — two switches, not one. Naming the sub-block after the level is what makes that second requirement visible in an application.conf instead of only in the docs.

readonly debugEventStream: "actor-ts.diagnostics.debug.event-stream" = 'actor-ts.diagnostics.debug.event-stream'

readonly debugLifecycle: "actor-ts.diagnostics.debug.lifecycle" = 'actor-ts.diagnostics.debug.lifecycle'

readonly debugUnhandled: "actor-ts.diagnostics.debug.unhandled" = 'actor-ts.diagnostics.debug.unhandled'

readonly logConfigOnStart: "actor-ts.diagnostics.log-config-on-start" = 'actor-ts.diagnostics.log-config-on-start'

readonly logDeadLetters: "actor-ts.diagnostics.log-dead-letters" = 'actor-ts.diagnostics.log-dead-letters'

readonly logDeadLettersDuringShutdown: "actor-ts.diagnostics.log-dead-letters-during-shutdown" = 'actor-ts.diagnostics.log-dead-letters-during-shutdown'

readonly logDeadLettersSuspendDuration: "actor-ts.diagnostics.log-dead-letters-suspend-duration" = 'actor-ts.diagnostics.log-dead-letters-suspend-duration'

readonly discovery: object

Seed-discovery provider settings — actor-ts.discovery.* (#860). Read once per bootstrapCluster by readAutoDiscoveryOptionsFromConfig (src/discovery/AutoDiscoveryOptions.ts), which layers them under the explicit AutoDiscoveryOptions and above the CLUSTER_* environment variables the providers already read.

Top-level rather than under cluster.* for the reason distributedData below is: the module is. src/discovery/ ships its own subpath export, a SeedProvider is built and then handed to the cluster, and the same providers serve a hand-wired Cluster.join that never bootstraps.

Leaf by leaf rather than a block root, for the reason reliableDelivery spells out: with no root above them, NoDeadConfigKeys has to find each leaf here by its exact path. Four of these seven ship no reference.conf leaf at all; the gate sets them only because the reader registry introduces each at one value and changes it to a second, which readAutoDiscoveryOptionsFromConfig has to answer differently.

dns.pinned-addresses, kubernetes.pinned-addresses, config.seeds and kubernetes.namespace are the comment-only four. The pins need “unset” to stay expressible — an always-present empty list cannot say “no pinning”, and no pinning is the default (#145). namespace and config.seeds have to stay unset for a precedence reason rather than an expressiveness one: each has a variable beneath it — CLUSTER_NAMESPACE, CLUSTER_SEEDS — and a published value would occupy the config layer on every node that configured nothing, which is exactly how the first cut of this block made CLUSTER_NAMESPACE unreachable. For config.seeds that holds even of [], which is not “unset”: it drops the static rung and silences the variable (#1499). The list itself is a deployment topology, correct on every node when it names the designated first node.

The two pin entries are spelled dnsPinnedAddresses / kubernetesPinnedAddresses rather than sharing one pinnedAddresses name under their own sub-blocks. That was for the substring search the dead-key gate ran before #1425, which reduced an accessor to its group plus its last segment, so two siblings with one final name vouched for each other. The perturbation gate changes each key on its own and reads no accessor names, so nothing depends on the distinct finals now.

readonly config: object

readonly seeds: "actor-ts.discovery.config.seeds" = 'actor-ts.discovery.config.seeds'

Comment-only in reference.conf — CLUSTER_SEEDS sits beneath it, and even [] would silence it.

readonly dns: object

readonly cacheTtl: "actor-ts.discovery.dns.cache-ttl" = 'actor-ts.discovery.dns.cache-ttl'

readonly dnsPinnedAddresses: "actor-ts.discovery.dns.pinned-addresses" = 'actor-ts.discovery.dns.pinned-addresses'

Comment-only in reference.conf — unset means no pinning.

readonly useSrv: "actor-ts.discovery.dns.use-srv" = 'actor-ts.discovery.dns.use-srv'

readonly kubernetes: object

discovery.kubernetes.kubernetesPinnedAddresses

Section titled “discovery.kubernetes.kubernetesPinnedAddresses”

readonly kubernetesPinnedAddresses: "actor-ts.discovery.kubernetes.pinned-addresses" = 'actor-ts.discovery.kubernetes.pinned-addresses'

Comment-only in reference.conf — unset means no pinning.

readonly namespace: "actor-ts.discovery.kubernetes.namespace" = 'actor-ts.discovery.kubernetes.namespace'

Comment-only in reference.conf — unset falls through to CLUSTER_NAMESPACE.

readonly requestTimeout: "actor-ts.discovery.kubernetes.request-timeout" = 'actor-ts.discovery.kubernetes.request-timeout'

readonly dispatcher: object

Dispatcher root — actor-ts.dispatcher.*.

readonly default: "actor-ts.dispatcher.default" = 'actor-ts.dispatcher.default'

readonly throughput: "actor-ts.dispatcher.throughput" = 'actor-ts.dispatcher.throughput'

readonly distributedData: object

DistributedData tuning — actor-ts.distributed-data.*. Read once per DistributedData.start, which layers them under the explicit options (#140, #856).

Top-level rather than under cluster.* (where pub-sub and receptionist sit) because the module is: DistributedData ships from src/crdt/, and its options type carries no cluster field — the cluster is a positional argument to start, not a tunable.

The two caps bound what one replica can be made to hold and how long it holds it. Each unsettled request keeps a promise, a timer and a target set alive until its deadline, so the cap is what turns a timeout storm into immediate rejections naming the knob. It is not a guard against the mailbox underneath — see DEFAULT_MAX_PENDING_QUORUM_REQUESTS for why that framing was dropped (#1078, #1148).

max-gossip-bytes bounds the third thing: what one outbound frame may carry. It reads as a size (1M), and it is clamped down to remote.max-frame-bytes at consume time — a budget above the wire cap is the configuration that reintroduces #691, so it is not expressible (#691).

log-data-size-exceeding reports on the same measurement one order of magnitude earlier and changes nothing: a key past it still gossips, it is merely named, because a value at a large fraction of the budget slows every other key’s sweep and nothing else says so. durable-keys is the only leaf here that is not a bound — it narrows what a configured durableStore writes, and an empty list means every key (#856).

quorum-timeout is the deadline a quorum call gets when it names none, resolved in the replicator so that max-quorum-timeout clamps it like a caller’s own. It shares its built-in value with actor.ask-timeout and nothing else: that key moves ActorRef.ask, and inheriting it would tie how long a replica holds a pending slot to an unrelated wait (#856).

readonly durableKeys: "actor-ts.distributed-data.durable-keys" = 'actor-ts.distributed-data.durable-keys'

readonly gossipInterval: "actor-ts.distributed-data.gossip-interval" = 'actor-ts.distributed-data.gossip-interval'

readonly logDataSizeExceeding: "actor-ts.distributed-data.log-data-size-exceeding" = 'actor-ts.distributed-data.log-data-size-exceeding'

readonly maxGossipBytes: "actor-ts.distributed-data.max-gossip-bytes" = 'actor-ts.distributed-data.max-gossip-bytes'

readonly maxPendingQuorumRequests: "actor-ts.distributed-data.max-pending-quorum-requests" = 'actor-ts.distributed-data.max-pending-quorum-requests'

readonly maxQuorumTimeout: "actor-ts.distributed-data.max-quorum-timeout" = 'actor-ts.distributed-data.max-quorum-timeout'

readonly quorumTimeout: "actor-ts.distributed-data.quorum-timeout" = 'actor-ts.distributed-data.quorum-timeout'

readonly http: object

HTTP subsystem config roots — actor-ts.http.*.

readonly backend: "actor-ts.http.backend" = 'actor-ts.http.backend'

Which shipped backend newServerAt(...).bind() uses when none is set in code.

readonly client: object

Outbound HttpClient defaults — the shared client and newClient(...).

readonly defaultTimeout: "actor-ts.http.client.default-timeout" = 'actor-ts.http.client.default-timeout'

readonly maxRedirects: "actor-ts.http.client.max-redirects" = 'actor-ts.http.client.max-redirects'

readonly maxResponseBytes: "actor-ts.http.client.max-response-bytes" = 'actor-ts.http.client.max-response-bytes'

readonly redirect: "actor-ts.http.client.redirect" = 'actor-ts.http.client.redirect'

readonly root: "actor-ts.http.client" = 'actor-ts.http.client'

readonly cors: object

Per-route CORS defaults for the cors(options, routes) directive (#878).

Full dotted leaves beside the root, for the reason websocket below spells out. Four of the six leaves are comment-only in reference.conf, so NoDeadConfigKeys has no literal of theirs to change: the reader registry introduces each at one value and changes it to a second, and readCorsOptionsFromConfig has to answer the two differently, as it has to answer to the two leaves that ship a value.

origins is settable here but the '*' wildcard is not: a value containing it is refused with a ConfigError naming this key, because withAnyOrigin() is documented as the explicit opt-in and #128 was about CORS defaults being too permissive. The predicate form has no path here either — a function cannot live in HOCON.

readonly allowedHeaders: "actor-ts.http.cors.allowed-headers" = 'actor-ts.http.cors.allowed-headers'

readonly credentials: "actor-ts.http.cors.credentials" = 'actor-ts.http.cors.credentials'

readonly exposedHeaders: "actor-ts.http.cors.exposed-headers" = 'actor-ts.http.cors.exposed-headers'

readonly maxAge: "actor-ts.http.cors.max-age" = 'actor-ts.http.cors.max-age'

readonly methods: "actor-ts.http.cors.methods" = 'actor-ts.http.cors.methods'

readonly origins: "actor-ts.http.cors.origins" = 'actor-ts.http.cors.origins'

readonly root: "actor-ts.http.cors" = 'actor-ts.http.cors'

readonly hsts: object

The policy hsts() / strictTransportSecurity() sends (#1462), read through the hook compile() resolves a config-aware middleware with.

Full dotted leaves beside the root, for the reason websocket below spells out. All three ship a value: none is computed and none has an “unset” state worth keeping, so the published literals are the built-in defaults themselves.

max-age is a count of SECONDS, read with getInt — getDuration would read 180d as milliseconds and send a 1000x pin. A max-age below a day (MINIMUM_CONFIGURED_HSTS_MAX_AGE_SECONDS, 86400) is refused with a ConfigError naming the key and the floor: 0 has every browser forget the pin, and a shorter one lapses before a visitor comes back the next day. Code may still set a value below it, 0 included.

It governs that middleware only. The hsts field of the securityHeaders() bundle and of withSecurityHeaders(...) is code-only.

readonly includeSubDomains: "actor-ts.http.hsts.include-sub-domains" = 'actor-ts.http.hsts.include-sub-domains'

readonly maxAge: "actor-ts.http.hsts.max-age" = 'actor-ts.http.hsts.max-age'

readonly preload: "actor-ts.http.hsts.preload" = 'actor-ts.http.hsts.preload'

readonly root: "actor-ts.http.hsts" = 'actor-ts.http.hsts'

readonly requestTimeout: object

The handler deadline requestTimeout() holds (#1463), read through the same hook as hsts. Not server.requestTimeout: that one bounds how long a peer takes to send a request and never a response, this one starts once the request has arrived and bounds the handler’s answer.

One leaf, deadline, the kebab-case of deadlineMs with the unit suffix dropped; read with getDuration. The response sent on timeout (onTimeout) is a function and has no leaf.

readonly deadline: "actor-ts.http.request-timeout.deadline" = 'actor-ts.http.request-timeout.deadline'

readonly root: "actor-ts.http.request-timeout" = 'actor-ts.http.request-timeout'

readonly server: object

Connection-level bounds for one bound server — the listening socket itself, not a route on it (#870).

Full dotted leaves beside the root, never a bare root, for the reason websocket below spells out; and here four keys — and the whole tls block — have no leaf in reference.conf at all, so a root-only declaration would have left them checked by nothing whatsoever.

idle-timeout, max-connections, max-content-length and max-header-bytes are the comment-only four. All need “unset” to stay expressible: unset keep-alive is whatever the backend picked — and the backends disagree on purpose, 72 s on Fastify against 5 s on node:http — unset max-connections is unlimited, and the two size caps unset keep each backend’s own. For those two, unset is also what a backend built with a cap of its own is measured against: a set key that differs from it is refused at bind(), and a published literal would set the key for everyone (#1488).

readonly headerTimeout: "actor-ts.http.server.header-timeout" = 'actor-ts.http.server.header-timeout'

readonly http2: "actor-ts.http.server.http2" = 'actor-ts.http.server.http2'

readonly idleTimeout: "actor-ts.http.server.idle-timeout" = 'actor-ts.http.server.idle-timeout'

Comment-only in reference.conf — unset keeps the backend’s own.

readonly maxConnections: "actor-ts.http.server.max-connections" = 'actor-ts.http.server.max-connections'

Comment-only in reference.conf — unset means unlimited.

readonly maxContentLength: "actor-ts.http.server.max-content-length" = 'actor-ts.http.server.max-content-length'

Comment-only in reference.conf — unset keeps each backend’s own body cap: the shared 1 MiB, or what withMaxBodyBytes / Fastify’s bodyLimit set.

readonly maxHeaderBytes: "actor-ts.http.server.max-header-bytes" = 'actor-ts.http.server.max-header-bytes'

Comment-only in reference.conf — unset keeps the runtime’s own header cap: node:http’s 16 KiB, or Bun’s process-wide --max-http-header-size.

readonly requestTimeout: "actor-ts.http.server.request-timeout" = 'actor-ts.http.server.request-timeout'

How long a peer may take to deliver a request — receiving only. A handler’s deadline is the other key, http.requestTimeout (#1463).

readonly root: "actor-ts.http.server" = 'actor-ts.http.server'

readonly tls: object

All comment-only in reference.conf: unset means plain HTTP, and there is no defensible path to publish. The three *-file leaves are read as paths and the files as PEM when the block is read, so the option type still carries contents, never paths (#1522).

readonly caFile: "actor-ts.http.server.tls.ca-file" = 'actor-ts.http.server.tls.ca-file'

readonly certFile: "actor-ts.http.server.tls.cert-file" = 'actor-ts.http.server.tls.cert-file'

readonly keyFile: "actor-ts.http.server.tls.key-file" = 'actor-ts.http.server.tls.key-file'

readonly rejectUnauthorized: "actor-ts.http.server.tls.reject-unauthorized" = 'actor-ts.http.server.tls.reject-unauthorized'

reject-unauthorized = false there leaves a client certificate unverified — supply ca-file instead.

readonly requestClientCert: "actor-ts.http.server.tls.request-client-cert" = 'actor-ts.http.server.tls.request-client-cert'

readonly shutdownGracePeriod: "actor-ts.http.shutdown-grace-period" = 'actor-ts.http.shutdown-grace-period'

How long unbind() lets in-flight requests drain before forcing.

readonly websocket: object

Server-side WebSocket defaults for websocket() routes.

Full dotted leaves under a root, not a bare block root, so each read site names its leaf through a typed accessor and a misspelt one does not compile. NoDeadConfigKeys leans on neither shape: the root makes any leaf beneath it reachable, declared or not, and the gate’s read half watches the readers, not this layout. #1405 renamed all nine of these leaves; a leaf renamed in reference.conf and not in its reader fails that half whatever this group declares, because the new spelling changes no registered reader’s answer.

readonly acceptTimeout: "actor-ts.http.websocket.accept-timeout" = 'actor-ts.http.websocket.accept-timeout'

readonly connectionMailboxCapacity: "actor-ts.http.websocket.connection-mailbox-capacity" = 'actor-ts.http.websocket.connection-mailbox-capacity'

Comment-only in reference.conf — unset means “no per-route bound”, so each connection actor falls through to a matching deployment entry, then to actor-ts.mailbox.default.* (#1432, #868).

readonly connectionMailboxOverflow: "actor-ts.http.websocket.connection-mailbox-overflow" = 'actor-ts.http.websocket.connection-mailbox-overflow'

Comment-only in reference.conf; only meaningful beside a capacity.

readonly maxBufferedBytes: "actor-ts.http.websocket.max-buffered-bytes" = 'actor-ts.http.websocket.max-buffered-bytes'

readonly maxConnections: "actor-ts.http.websocket.max-connections" = 'actor-ts.http.websocket.max-connections'

Comment-only in reference.conf — unset means unlimited.

readonly maxFrameBytes: "actor-ts.http.websocket.max-frame-bytes" = 'actor-ts.http.websocket.max-frame-bytes'

readonly maxPreAttachBytes: "actor-ts.http.websocket.max-pre-attach-bytes" = 'actor-ts.http.websocket.max-pre-attach-bytes'

readonly maxPreAttachFrames: "actor-ts.http.websocket.max-pre-attach-frames" = 'actor-ts.http.websocket.max-pre-attach-frames'

readonly onBackpressure: "actor-ts.http.websocket.on-backpressure" = 'actor-ts.http.websocket.on-backpressure'

readonly onInvalidMessage: "actor-ts.http.websocket.on-invalid-message" = 'actor-ts.http.websocket.on-invalid-message'

readonly onOversizeFrame: "actor-ts.http.websocket.on-oversize-frame" = 'actor-ts.http.websocket.on-oversize-frame'

readonly root: "actor-ts.http.websocket" = 'actor-ts.http.websocket'

readonly io: object

IO broker blocks — actor-ts.io.broker.* (#1443).

Each block is a group: the root its actor’s configKey() returns, and every leaf of the protocol’s own as a full dotted path, which the block’s read…OptionsFromConfig reads the system config through. None of them publishes a reference.conf leaf (#871) — their keys are required or unset, with no default worth shipping — so NoDeadConfigKeys sees a broker leaf only as the reader registry introduces it, through the same accessor the reader reads. That proves the reader reads the key, not that the key is spelled right: these entries are where a misspelt leaf has to be caught.

The leaves every broker shares — reconnect, circuit-breaker, outbound-buffer — are not listed under each root: one shape hangs under every broker’s root, and under any an out-of-tree subclass picks, so brokerCommonKeysUnder composes them, as redisCacheKeysUnder composes a named cache’s. The framing block the two TCP roots share is composed too, by tcpFramingKeysUnder, but its roots are fixed, so it is listed under both.

readonly broker: object

readonly amqp: object

AmqpActor.

readonly autoAcknowledge: "actor-ts.io.broker.amqp.auto-acknowledge" = 'actor-ts.io.broker.amqp.auto-acknowledge'

readonly prefetch: "actor-ts.io.broker.amqp.prefetch" = 'actor-ts.io.broker.amqp.prefetch'

readonly root: "actor-ts.io.broker.amqp" = 'actor-ts.io.broker.amqp'

readonly url: "actor-ts.io.broker.amqp.url" = 'actor-ts.io.broker.amqp.url'

readonly emailBridge: object

The IMAP-in / SMTP-out mail bridge (#1133). One root for both halves: they are two sides of one connection lifecycle, and a bridge configured with only one of them is the normal case rather than a degenerate one. Each half is read as a whole, so an imap or smtp group passed in code replaces the configured one.

readonly imap: object

io.broker.emailBridge.imap.acknowledgmentTimeout

Section titled “io.broker.emailBridge.imap.acknowledgmentTimeout”

readonly acknowledgmentTimeout: "actor-ts.io.broker.email-bridge.imap.acknowledgment-timeout" = 'actor-ts.io.broker.email-bridge.imap.acknowledgment-timeout'

readonly disableIdle: "actor-ts.io.broker.email-bridge.imap.disable-idle" = 'actor-ts.io.broker.email-bridge.imap.disable-idle'

readonly host: "actor-ts.io.broker.email-bridge.imap.host" = 'actor-ts.io.broker.email-bridge.imap.host'

readonly mailbox: "actor-ts.io.broker.email-bridge.imap.mailbox" = 'actor-ts.io.broker.email-bridge.imap.mailbox'

readonly maxIdleTime: "actor-ts.io.broker.email-bridge.imap.max-idle-time" = 'actor-ts.io.broker.email-bridge.imap.max-idle-time'

io.broker.emailBridge.imap.maxMessageBytes

Section titled “io.broker.emailBridge.imap.maxMessageBytes”

readonly maxMessageBytes: "actor-ts.io.broker.email-bridge.imap.max-message-bytes" = 'actor-ts.io.broker.email-bridge.imap.max-message-bytes'

A size: 25M reads as 26 214 400 bytes.

readonly moveToMailbox: "actor-ts.io.broker.email-bridge.imap.move-to-mailbox" = 'actor-ts.io.broker.email-bridge.imap.move-to-mailbox'

readonly onProcessed: "actor-ts.io.broker.email-bridge.imap.on-processed" = 'actor-ts.io.broker.email-bridge.imap.on-processed'

readonly password: "actor-ts.io.broker.email-bridge.imap.password" = 'actor-ts.io.broker.email-bridge.imap.password'

readonly pollInterval: "actor-ts.io.broker.email-bridge.imap.poll-interval" = 'actor-ts.io.broker.email-bridge.imap.poll-interval'

readonly port: "actor-ts.io.broker.email-bridge.imap.port" = 'actor-ts.io.broker.email-bridge.imap.port'

readonly root: "actor-ts.io.broker.email-bridge.imap" = 'actor-ts.io.broker.email-bridge.imap'

readonly secure: "actor-ts.io.broker.email-bridge.imap.secure" = 'actor-ts.io.broker.email-bridge.imap.secure'

readonly user: "actor-ts.io.broker.email-bridge.imap.user" = 'actor-ts.io.broker.email-bridge.imap.user'

readonly root: "actor-ts.io.broker.email-bridge" = 'actor-ts.io.broker.email-bridge'

readonly smtp: object

readonly from: "actor-ts.io.broker.email-bridge.smtp.from" = 'actor-ts.io.broker.email-bridge.smtp.from'

readonly host: "actor-ts.io.broker.email-bridge.smtp.host" = 'actor-ts.io.broker.email-bridge.smtp.host'

readonly maxConnections: "actor-ts.io.broker.email-bridge.smtp.max-connections" = 'actor-ts.io.broker.email-bridge.smtp.max-connections'

readonly maxMessages: "actor-ts.io.broker.email-bridge.smtp.max-messages" = 'actor-ts.io.broker.email-bridge.smtp.max-messages'

readonly password: "actor-ts.io.broker.email-bridge.smtp.password" = 'actor-ts.io.broker.email-bridge.smtp.password'

readonly port: "actor-ts.io.broker.email-bridge.smtp.port" = 'actor-ts.io.broker.email-bridge.smtp.port'

readonly root: "actor-ts.io.broker.email-bridge.smtp" = 'actor-ts.io.broker.email-bridge.smtp'

readonly secure: "actor-ts.io.broker.email-bridge.smtp.secure" = 'actor-ts.io.broker.email-bridge.smtp.secure'

readonly user: "actor-ts.io.broker.email-bridge.smtp.user" = 'actor-ts.io.broker.email-bridge.smtp.user'

readonly grpc: object

readonly client: object

GrpcClientActor. proto-path is one file or a list of them.

readonly deadline: "actor-ts.io.broker.grpc.client.deadline" = 'actor-ts.io.broker.grpc.client.deadline'

readonly endpoint: "actor-ts.io.broker.grpc.client.endpoint" = 'actor-ts.io.broker.grpc.client.endpoint'

readonly packageName: "actor-ts.io.broker.grpc.client.package-name" = 'actor-ts.io.broker.grpc.client.package-name'

readonly protoPath: "actor-ts.io.broker.grpc.client.proto-path" = 'actor-ts.io.broker.grpc.client.proto-path'

readonly root: "actor-ts.io.broker.grpc.client" = 'actor-ts.io.broker.grpc.client'

readonly serviceName: "actor-ts.io.broker.grpc.client.service-name" = 'actor-ts.io.broker.grpc.client.service-name'

readonly server: object

GrpcServerActor — a plain actor, not a BrokerActor, so it shares none of the reconnect / breaker / buffer leaves and refuses its own retired spellings itself.

readonly bind: "actor-ts.io.broker.grpc.server.bind" = 'actor-ts.io.broker.grpc.server.bind'

readonly packageName: "actor-ts.io.broker.grpc.server.package-name" = 'actor-ts.io.broker.grpc.server.package-name'

readonly protoPath: "actor-ts.io.broker.grpc.server.proto-path" = 'actor-ts.io.broker.grpc.server.proto-path'

readonly root: "actor-ts.io.broker.grpc.server" = 'actor-ts.io.broker.grpc.server'

readonly serviceName: "actor-ts.io.broker.grpc.server.service-name" = 'actor-ts.io.broker.grpc.server.service-name'

readonly jetstream: object

JetStreamActor. stream and consumer are each read whole once there — stream.name, stream.subjects and consumer.durable are required inside them — and consumer.deliver-policy is either a string (all, last, new) or a block whose kind picks start-seq or start-time.

readonly acknowledgmentTimeout: "actor-ts.io.broker.jetstream.acknowledgment-timeout" = 'actor-ts.io.broker.jetstream.acknowledgment-timeout'

readonly consumer: object

readonly ackPolicy: "actor-ts.io.broker.jetstream.consumer.ack-policy" = 'actor-ts.io.broker.jetstream.consumer.ack-policy'

readonly ackWait: "actor-ts.io.broker.jetstream.consumer.ack-wait" = 'actor-ts.io.broker.jetstream.consumer.ack-wait'

readonly create: "actor-ts.io.broker.jetstream.consumer.create" = 'actor-ts.io.broker.jetstream.consumer.create'

io.broker.jetstream.consumer.deliverPolicy

Section titled “io.broker.jetstream.consumer.deliverPolicy”

readonly deliverPolicy: object

io.broker.jetstream.consumer.deliverPolicy.kind

Section titled “io.broker.jetstream.consumer.deliverPolicy.kind”

readonly kind: "actor-ts.io.broker.jetstream.consumer.deliver-policy.kind" = 'actor-ts.io.broker.jetstream.consumer.deliver-policy.kind'

io.broker.jetstream.consumer.deliverPolicy.root

Section titled “io.broker.jetstream.consumer.deliverPolicy.root”

readonly root: "actor-ts.io.broker.jetstream.consumer.deliver-policy" = 'actor-ts.io.broker.jetstream.consumer.deliver-policy'

io.broker.jetstream.consumer.deliverPolicy.startSeq

Section titled “io.broker.jetstream.consumer.deliverPolicy.startSeq”

readonly startSeq: "actor-ts.io.broker.jetstream.consumer.deliver-policy.start-seq" = 'actor-ts.io.broker.jetstream.consumer.deliver-policy.start-seq'

io.broker.jetstream.consumer.deliverPolicy.startTime

Section titled “io.broker.jetstream.consumer.deliverPolicy.startTime”

readonly startTime: "actor-ts.io.broker.jetstream.consumer.deliver-policy.start-time" = 'actor-ts.io.broker.jetstream.consumer.deliver-policy.start-time'

Epoch milliseconds — an instant, not a duration.

readonly durable: "actor-ts.io.broker.jetstream.consumer.durable" = 'actor-ts.io.broker.jetstream.consumer.durable'

io.broker.jetstream.consumer.filterSubject

Section titled “io.broker.jetstream.consumer.filterSubject”

readonly filterSubject: "actor-ts.io.broker.jetstream.consumer.filter-subject" = 'actor-ts.io.broker.jetstream.consumer.filter-subject'

io.broker.jetstream.consumer.maxAcknowledgmentPending

Section titled “io.broker.jetstream.consumer.maxAcknowledgmentPending”

readonly maxAcknowledgmentPending: "actor-ts.io.broker.jetstream.consumer.max-acknowledgment-pending" = 'actor-ts.io.broker.jetstream.consumer.max-acknowledgment-pending'

readonly mode: "actor-ts.io.broker.jetstream.consumer.mode" = 'actor-ts.io.broker.jetstream.consumer.mode'

readonly root: "actor-ts.io.broker.jetstream.consumer" = 'actor-ts.io.broker.jetstream.consumer'

readonly name: "actor-ts.io.broker.jetstream.name" = 'actor-ts.io.broker.jetstream.name'

readonly password: "actor-ts.io.broker.jetstream.password" = 'actor-ts.io.broker.jetstream.password'

readonly root: "actor-ts.io.broker.jetstream" = 'actor-ts.io.broker.jetstream'

readonly servers: "actor-ts.io.broker.jetstream.servers" = 'actor-ts.io.broker.jetstream.servers'

readonly stream: object

readonly create: "actor-ts.io.broker.jetstream.stream.create" = 'actor-ts.io.broker.jetstream.stream.create'

readonly maxAge: "actor-ts.io.broker.jetstream.stream.max-age" = 'actor-ts.io.broker.jetstream.stream.max-age'

Nanoseconds, handed to nats.js verbatim — a count, not a duration.

readonly maxBytes: "actor-ts.io.broker.jetstream.stream.max-bytes" = 'actor-ts.io.broker.jetstream.stream.max-bytes'

readonly maxMessages: "actor-ts.io.broker.jetstream.stream.max-messages" = 'actor-ts.io.broker.jetstream.stream.max-messages'

readonly name: "actor-ts.io.broker.jetstream.stream.name" = 'actor-ts.io.broker.jetstream.stream.name'

readonly retention: "actor-ts.io.broker.jetstream.stream.retention" = 'actor-ts.io.broker.jetstream.stream.retention'

readonly root: "actor-ts.io.broker.jetstream.stream" = 'actor-ts.io.broker.jetstream.stream'

readonly storage: "actor-ts.io.broker.jetstream.stream.storage" = 'actor-ts.io.broker.jetstream.stream.storage'

readonly subjects: "actor-ts.io.broker.jetstream.stream.subjects" = 'actor-ts.io.broker.jetstream.stream.subjects'

readonly token: "actor-ts.io.broker.jetstream.token" = 'actor-ts.io.broker.jetstream.token'

readonly user: "actor-ts.io.broker.jetstream.user" = 'actor-ts.io.broker.jetstream.user'

readonly jetstreamKeyValue: object

JetStream’s KV and Object-Store views (#74) are separate actors on separate roots, not sub-blocks of jetstream: they configure a bucket, not a stream + consumer, and nesting them would put keys like history under a block whose reader never looks at them.

readonly bucket: "actor-ts.io.broker.jetstream-key-value.bucket" = 'actor-ts.io.broker.jetstream-key-value.bucket'

readonly create: "actor-ts.io.broker.jetstream-key-value.create" = 'actor-ts.io.broker.jetstream-key-value.create'

readonly history: "actor-ts.io.broker.jetstream-key-value.history" = 'actor-ts.io.broker.jetstream-key-value.history'

readonly maxValueBytes: "actor-ts.io.broker.jetstream-key-value.max-value-bytes" = 'actor-ts.io.broker.jetstream-key-value.max-value-bytes'

readonly name: "actor-ts.io.broker.jetstream-key-value.name" = 'actor-ts.io.broker.jetstream-key-value.name'

readonly password: "actor-ts.io.broker.jetstream-key-value.password" = 'actor-ts.io.broker.jetstream-key-value.password'

readonly replicas: "actor-ts.io.broker.jetstream-key-value.replicas" = 'actor-ts.io.broker.jetstream-key-value.replicas'

readonly root: "actor-ts.io.broker.jetstream-key-value" = 'actor-ts.io.broker.jetstream-key-value'

readonly servers: "actor-ts.io.broker.jetstream-key-value.servers" = 'actor-ts.io.broker.jetstream-key-value.servers'

readonly storage: "actor-ts.io.broker.jetstream-key-value.storage" = 'actor-ts.io.broker.jetstream-key-value.storage'

readonly timeToLive: "actor-ts.io.broker.jetstream-key-value.time-to-live" = 'actor-ts.io.broker.jetstream-key-value.time-to-live'

readonly token: "actor-ts.io.broker.jetstream-key-value.token" = 'actor-ts.io.broker.jetstream-key-value.token'

readonly user: "actor-ts.io.broker.jetstream-key-value.user" = 'actor-ts.io.broker.jetstream-key-value.user'

readonly jetstreamObjectStore: object

readonly bucket: "actor-ts.io.broker.jetstream-object-store.bucket" = 'actor-ts.io.broker.jetstream-object-store.bucket'

readonly create: "actor-ts.io.broker.jetstream-object-store.create" = 'actor-ts.io.broker.jetstream-object-store.create'

io.broker.jetstreamObjectStore.description

Section titled “io.broker.jetstreamObjectStore.description”

readonly description: "actor-ts.io.broker.jetstream-object-store.description" = 'actor-ts.io.broker.jetstream-object-store.description'

io.broker.jetstreamObjectStore.maxObjectBytes

Section titled “io.broker.jetstreamObjectStore.maxObjectBytes”

readonly maxObjectBytes: "actor-ts.io.broker.jetstream-object-store.max-object-bytes" = 'actor-ts.io.broker.jetstream-object-store.max-object-bytes'

readonly name: "actor-ts.io.broker.jetstream-object-store.name" = 'actor-ts.io.broker.jetstream-object-store.name'

readonly password: "actor-ts.io.broker.jetstream-object-store.password" = 'actor-ts.io.broker.jetstream-object-store.password'

readonly replicas: "actor-ts.io.broker.jetstream-object-store.replicas" = 'actor-ts.io.broker.jetstream-object-store.replicas'

readonly root: "actor-ts.io.broker.jetstream-object-store" = 'actor-ts.io.broker.jetstream-object-store'

readonly servers: "actor-ts.io.broker.jetstream-object-store.servers" = 'actor-ts.io.broker.jetstream-object-store.servers'

readonly storage: "actor-ts.io.broker.jetstream-object-store.storage" = 'actor-ts.io.broker.jetstream-object-store.storage'

readonly token: "actor-ts.io.broker.jetstream-object-store.token" = 'actor-ts.io.broker.jetstream-object-store.token'

readonly user: "actor-ts.io.broker.jetstream-object-store.user" = 'actor-ts.io.broker.jetstream-object-store.user'

readonly kafka: object

KafkaActor. sasl is read whole once there — mechanism, username and password are all required in it — while producer and consumer take any subset of their leaves.

readonly brokers: "actor-ts.io.broker.kafka.brokers" = 'actor-ts.io.broker.kafka.brokers'

readonly clientId: "actor-ts.io.broker.kafka.client-id" = 'actor-ts.io.broker.kafka.client-id'

readonly consumer: object

readonly commitMode: "actor-ts.io.broker.kafka.consumer.commit-mode" = 'actor-ts.io.broker.kafka.consumer.commit-mode'

readonly commitTimeout: "actor-ts.io.broker.kafka.consumer.commit-timeout" = 'actor-ts.io.broker.kafka.consumer.commit-timeout'

readonly fromBeginning: "actor-ts.io.broker.kafka.consumer.from-beginning" = 'actor-ts.io.broker.kafka.consumer.from-beginning'

readonly groupId: "actor-ts.io.broker.kafka.consumer.group-id" = 'actor-ts.io.broker.kafka.consumer.group-id'

readonly root: "actor-ts.io.broker.kafka.consumer" = 'actor-ts.io.broker.kafka.consumer'

readonly producer: object

io.broker.kafka.producer.allowAutoTopicCreation

Section titled “io.broker.kafka.producer.allowAutoTopicCreation”

readonly allowAutoTopicCreation: "actor-ts.io.broker.kafka.producer.allow-auto-topic-creation" = 'actor-ts.io.broker.kafka.producer.allow-auto-topic-creation'

readonly idempotent: "actor-ts.io.broker.kafka.producer.idempotent" = 'actor-ts.io.broker.kafka.producer.idempotent'

readonly root: "actor-ts.io.broker.kafka.producer" = 'actor-ts.io.broker.kafka.producer'

readonly root: "actor-ts.io.broker.kafka" = 'actor-ts.io.broker.kafka'

readonly sasl: object

readonly mechanism: "actor-ts.io.broker.kafka.sasl.mechanism" = 'actor-ts.io.broker.kafka.sasl.mechanism'

readonly password: "actor-ts.io.broker.kafka.sasl.password" = 'actor-ts.io.broker.kafka.sasl.password'

readonly root: "actor-ts.io.broker.kafka.sasl" = 'actor-ts.io.broker.kafka.sasl'

readonly username: "actor-ts.io.broker.kafka.sasl.username" = 'actor-ts.io.broker.kafka.sasl.username'

readonly ssl: "actor-ts.io.broker.kafka.ssl" = 'actor-ts.io.broker.kafka.ssl'

Boolean only: the certificate-material form of ssl is code-only.

readonly topics: "actor-ts.io.broker.kafka.topics" = 'actor-ts.io.broker.kafka.topics'

readonly mqtt: object

MqttActor. keep-alive is a duration in whole seconds, the unit MQTT carries it in: 30s is 30, a sub-second value is refused, and 0 still switches it off.

readonly brokerUrl: "actor-ts.io.broker.mqtt.broker-url" = 'actor-ts.io.broker.mqtt.broker-url'

readonly cleanSession: "actor-ts.io.broker.mqtt.clean-session" = 'actor-ts.io.broker.mqtt.clean-session'

readonly clientId: "actor-ts.io.broker.mqtt.client-id" = 'actor-ts.io.broker.mqtt.client-id'

readonly credentials: object

readonly password: "actor-ts.io.broker.mqtt.credentials.password" = 'actor-ts.io.broker.mqtt.credentials.password'

readonly root: "actor-ts.io.broker.mqtt.credentials" = 'actor-ts.io.broker.mqtt.credentials'

readonly username: "actor-ts.io.broker.mqtt.credentials.username" = 'actor-ts.io.broker.mqtt.credentials.username'

readonly keepAlive: "actor-ts.io.broker.mqtt.keep-alive" = 'actor-ts.io.broker.mqtt.keep-alive'

readonly protocolVersion: "actor-ts.io.broker.mqtt.protocol-version" = 'actor-ts.io.broker.mqtt.protocol-version'

readonly qos: "actor-ts.io.broker.mqtt.qos" = 'actor-ts.io.broker.mqtt.qos'

readonly root: "actor-ts.io.broker.mqtt" = 'actor-ts.io.broker.mqtt'

readonly will: object

readonly payload: "actor-ts.io.broker.mqtt.will.payload" = 'actor-ts.io.broker.mqtt.will.payload'

readonly qos: "actor-ts.io.broker.mqtt.will.qos" = 'actor-ts.io.broker.mqtt.will.qos'

readonly retain: "actor-ts.io.broker.mqtt.will.retain" = 'actor-ts.io.broker.mqtt.will.retain'

readonly root: "actor-ts.io.broker.mqtt.will" = 'actor-ts.io.broker.mqtt.will'

readonly topic: "actor-ts.io.broker.mqtt.will.topic" = 'actor-ts.io.broker.mqtt.will.topic'

readonly nats: object

NatsActor.

readonly name: "actor-ts.io.broker.nats.name" = 'actor-ts.io.broker.nats.name'

readonly password: "actor-ts.io.broker.nats.password" = 'actor-ts.io.broker.nats.password'

readonly root: "actor-ts.io.broker.nats" = 'actor-ts.io.broker.nats'

readonly servers: "actor-ts.io.broker.nats.servers" = 'actor-ts.io.broker.nats.servers'

readonly token: "actor-ts.io.broker.nats.token" = 'actor-ts.io.broker.nats.token'

readonly user: "actor-ts.io.broker.nats.user" = 'actor-ts.io.broker.nats.user'

readonly redisStreams: object

RedisStreamsActor. consumer-group is read as a whole once it is there: group and consumer are both required inside it.

readonly block: "actor-ts.io.broker.redis-streams.block" = 'actor-ts.io.broker.redis-streams.block'

readonly consumerGroup: object

io.broker.redisStreams.consumerGroup.consumer

Section titled “io.broker.redisStreams.consumerGroup.consumer”

readonly consumer: "actor-ts.io.broker.redis-streams.consumer-group.consumer" = 'actor-ts.io.broker.redis-streams.consumer-group.consumer'

io.broker.redisStreams.consumerGroup.createIfMissing

Section titled “io.broker.redisStreams.consumerGroup.createIfMissing”

readonly createIfMissing: "actor-ts.io.broker.redis-streams.consumer-group.create-if-missing" = 'actor-ts.io.broker.redis-streams.consumer-group.create-if-missing'

io.broker.redisStreams.consumerGroup.group

Section titled “io.broker.redisStreams.consumerGroup.group”

readonly group: "actor-ts.io.broker.redis-streams.consumer-group.group" = 'actor-ts.io.broker.redis-streams.consumer-group.group'

readonly root: "actor-ts.io.broker.redis-streams.consumer-group" = 'actor-ts.io.broker.redis-streams.consumer-group'

readonly root: "actor-ts.io.broker.redis-streams" = 'actor-ts.io.broker.redis-streams'

readonly streams: "actor-ts.io.broker.redis-streams.streams" = 'actor-ts.io.broker.redis-streams.streams'

readonly url: "actor-ts.io.broker.redis-streams.url" = 'actor-ts.io.broker.redis-streams.url'

readonly sse: object

SseActor. headers is a block of header names, read whole.

readonly connectTimeout: "actor-ts.io.broker.sse.connect-timeout" = 'actor-ts.io.broker.sse.connect-timeout'

readonly headers: "actor-ts.io.broker.sse.headers" = 'actor-ts.io.broker.sse.headers'

readonly idleTimeout: "actor-ts.io.broker.sse.idle-timeout" = 'actor-ts.io.broker.sse.idle-timeout'

readonly root: "actor-ts.io.broker.sse" = 'actor-ts.io.broker.sse'

readonly url: "actor-ts.io.broker.sse.url" = 'actor-ts.io.broker.sse.url'

readonly tcp: object

TcpSocketActor. framing is the block both TCP actors carry, so its leaves come from tcpFramingKeysUnder under each root, and readFramingFromConfig reads either copy.

readonly connectTimeout: "actor-ts.io.broker.tcp.connect-timeout" = 'actor-ts.io.broker.tcp.connect-timeout'

readonly framing: object

readonly delimiter: "actor-ts.io.broker.tcp.framing.delimiter"

readonly kind: "actor-ts.io.broker.tcp.framing.kind"

readonly maxFrameBytes: "actor-ts.io.broker.tcp.framing.max-frame-bytes"

readonly maxLineBytes: "actor-ts.io.broker.tcp.framing.max-line-bytes"

root: "actor-ts.io.broker.tcp.framing"

readonly host: "actor-ts.io.broker.tcp.host" = 'actor-ts.io.broker.tcp.host'

readonly idleTimeout: "actor-ts.io.broker.tcp.idle-timeout" = 'actor-ts.io.broker.tcp.idle-timeout'

readonly keepAlive: "actor-ts.io.broker.tcp.keep-alive" = 'actor-ts.io.broker.tcp.keep-alive'

readonly port: "actor-ts.io.broker.tcp.port" = 'actor-ts.io.broker.tcp.port'

readonly root: "actor-ts.io.broker.tcp" = 'actor-ts.io.broker.tcp'

readonly tcpServer: object

The TCP listener (TcpServerActor), on its own root rather than a sub-block of tcp: it configures a bind address and an admission cap, not a remote endpoint, so the two blocks share only framing.

readonly bindHost: "actor-ts.io.broker.tcp-server.bind-host" = 'actor-ts.io.broker.tcp-server.bind-host'

readonly bindPort: "actor-ts.io.broker.tcp-server.bind-port" = 'actor-ts.io.broker.tcp-server.bind-port'

readonly framing: object

readonly delimiter: "actor-ts.io.broker.tcp-server.framing.delimiter"

readonly kind: "actor-ts.io.broker.tcp-server.framing.kind"

readonly maxFrameBytes: "actor-ts.io.broker.tcp-server.framing.max-frame-bytes"

readonly maxLineBytes: "actor-ts.io.broker.tcp-server.framing.max-line-bytes"

root: "actor-ts.io.broker.tcp-server.framing"

readonly maxConnections: "actor-ts.io.broker.tcp-server.max-connections" = 'actor-ts.io.broker.tcp-server.max-connections'

The admission cap; unset means unlimited.

readonly root: "actor-ts.io.broker.tcp-server" = 'actor-ts.io.broker.tcp-server'

readonly udp: object

UdpSocketActor.

readonly bindHost: "actor-ts.io.broker.udp.bind-host" = 'actor-ts.io.broker.udp.bind-host'

readonly bindPort: "actor-ts.io.broker.udp.bind-port" = 'actor-ts.io.broker.udp.bind-port'

readonly root: "actor-ts.io.broker.udp" = 'actor-ts.io.broker.udp'

readonly type: "actor-ts.io.broker.udp.type" = 'actor-ts.io.broker.udp.type'

readonly websocket: object

WebsocketClientActor — the client side. The server’s own block is http.websocket, and its on-invalid-message takes a different list of values than this one.

readonly connectTimeout: "actor-ts.io.broker.websocket.connect-timeout" = 'actor-ts.io.broker.websocket.connect-timeout'

readonly idleTimeout: "actor-ts.io.broker.websocket.idle-timeout" = 'actor-ts.io.broker.websocket.idle-timeout'

readonly inboundHighWaterMark: "actor-ts.io.broker.websocket.inbound-high-water-mark" = 'actor-ts.io.broker.websocket.inbound-high-water-mark'

readonly inboundLowWaterMark: "actor-ts.io.broker.websocket.inbound-low-water-mark" = 'actor-ts.io.broker.websocket.inbound-low-water-mark'

readonly maxFrameBytes: "actor-ts.io.broker.websocket.max-frame-bytes" = 'actor-ts.io.broker.websocket.max-frame-bytes'

readonly onInvalidMessage: "actor-ts.io.broker.websocket.on-invalid-message" = 'actor-ts.io.broker.websocket.on-invalid-message'

readonly pingInterval: "actor-ts.io.broker.websocket.ping-interval" = 'actor-ts.io.broker.websocket.ping-interval'

readonly protocols: "actor-ts.io.broker.websocket.protocols" = 'actor-ts.io.broker.websocket.protocols'

readonly root: "actor-ts.io.broker.websocket" = 'actor-ts.io.broker.websocket'

readonly url: "actor-ts.io.broker.websocket.url" = 'actor-ts.io.broker.websocket.url'

readonly logger: object

Logger root — actor-ts.logger.*.

readonly closeTimeout: "actor-ts.logger.close-timeout" = 'actor-ts.logger.close-timeout'

readonly level: "actor-ts.logger.level" = 'actor-ts.logger.level'

readonly sinks: object

One block root per sink. Each is read as a block by the matching readXSinkOptionsFromConfig, so the leaves under it (enabled, min-level, …) need no entry of their own: the root is what makes them reachable for NoDeadConfigKeys, whose read half runs the readers rather than looking here. The cache and persistence plugin blocks have a root too, but list their leaves beside it, as the typed key sets their readers are handed.

readonly console: "actor-ts.logger.sinks.console" = 'actor-ts.logger.sinks.console'

readonly file: "actor-ts.logger.sinks.file" = 'actor-ts.logger.sinks.file'

readonly gelf: "actor-ts.logger.sinks.gelf" = 'actor-ts.logger.sinks.gelf'

readonly loki: "actor-ts.logger.sinks.loki" = 'actor-ts.logger.sinks.loki'

readonly otlp: "actor-ts.logger.sinks.otlp" = 'actor-ts.logger.sinks.otlp'

readonly parseable: "actor-ts.logger.sinks.parseable" = 'actor-ts.logger.sinks.parseable'

readonly seq: "actor-ts.logger.sinks.seq" = 'actor-ts.logger.sinks.seq'

readonly splunk: "actor-ts.logger.sinks.splunk" = 'actor-ts.logger.sinks.splunk'

readonly syslog: "actor-ts.logger.sinks.syslog" = 'actor-ts.logger.sinks.syslog'

readonly mailbox: object

The global mailbox bound — actor-ts.mailbox.default.* (#862).

Read once, in the ActorSystem constructor, and layered under the per-spawn ActorOptions in ActorCell, with the deployment entry matching the actor’s path between the two (#868): explicit options win, then that entry, then this block, and the built-in answer is still “unbounded”. This block and an entry’s mailbox-capacity are the two knobs in the file that can introduce message loss in an actor whose spawn site says nothing about a mailbox — this one in every actor the application wrote at once — which is why the reference comment spends more lines on the scope than on the values.

Full dotted leaves rather than a mailbox block root, for the reason spelled out under diagnostics below: with no root above them, NoDeadConfigKeys has to find each leaf here by its exact path to count it reachable.

readonly default: object

readonly capacity: "actor-ts.mailbox.default.capacity" = 'actor-ts.mailbox.default.capacity'

readonly overflow: "actor-ts.mailbox.default.overflow" = 'actor-ts.mailbox.default.overflow'

readonly management: object

The management HTTP surface — actor-ts.management.*. Two readers, one block: readManagementRoutesOptionsFromConfig supplies what managementRoutes layers under its explicit options, and readHealthCheckRegistryOptionsFromConfig supplies the per-check deadline the shared HealthCheckRegistry is built with. They are separate because the registry exists from the first healthChecksOf(system) call, usually long before anything builds a route tree.

Every leaf is spelled out rather than covered by a block root (#882): a root alone satisfies the NoDeadConfigKeys reachability check for everything beneath it, a misspelt leaf included. That each leaf is read is the gate’s other half, which no layout here decides.

auth and ipAllowlist have no path here and cannot get one — they are Middleware functions, which HOCON has no way to express. That is what makes the block unable to weaken the security wiring: it decides which endpoints exist and where the probes answer, never who may reach them.

readonly authProtectHealth: "actor-ts.management.auth-protect-health" = 'actor-ts.management.auth-protect-health'

readonly enableDownEndpoint: "actor-ts.management.enable-down-endpoint" = 'actor-ts.management.enable-down-endpoint'

readonly enableLeaveEndpoint: "actor-ts.management.enable-leave-endpoint" = 'actor-ts.management.enable-leave-endpoint'

readonly enableMetricsEndpoint: "actor-ts.management.enable-metrics-endpoint" = 'actor-ts.management.enable-metrics-endpoint'

readonly healthChecks: object

readonly checkTimeout: "actor-ts.management.health-checks.check-timeout" = 'actor-ts.management.health-checks.check-timeout'

readonly livenessPath: "actor-ts.management.liveness-path" = 'actor-ts.management.liveness-path'

readonly readinessPath: "actor-ts.management.readiness-path" = 'actor-ts.management.readiness-path'

readonly messageBoundary: object

Message-boundary checks — actor-ts.diagnostics.message-boundary.* (#1386). Its own group, read by readMessageBoundaryOptionsFromConfig rather than the diagnostics reader, so each reader’s guard pins exactly the leaves it reads.

readonly serializerRoundTrip: "actor-ts.diagnostics.message-boundary.serializer-round-trip" = 'actor-ts.diagnostics.message-boundary.serializer-round-trip'

readonly structuredClone: "actor-ts.diagnostics.message-boundary.structured-clone" = 'actor-ts.diagnostics.message-boundary.structured-clone'

readonly metrics: object

The registries MetricsExtension builds — actor-ts.metrics.* (#1466). Two readers, one block, because the two registries take different slices of it: readMetricsRegistryOptionsFromConfig feeds enable(), whose in-process registry has a cap and no prefix concept, and readPromClientAdapterOptionsFromConfig feeds enablePromClient(), whose prom-client bridge takes both.

The block is about the registry and nothing else. The scrape endpoint and the worker-mesh relay keep their switches where they are served (management.enable-metrics-endpoint, worker-mesh.metrics-relay-interval), since those are read by the route tree and the mesh, which never build a registry.

Every leaf is spelled out rather than covered by a block root: a root alone satisfies the NoDeadConfigKeys reachability check for everything beneath it.

readonly maxSeriesPerFamily: "actor-ts.metrics.max-series-per-family" = 'actor-ts.metrics.max-series-per-family'

readonly namePrefix: "actor-ts.metrics.name-prefix" = 'actor-ts.metrics.name-prefix'

readonly offloadPool: object

The function-level offload pool — actor-ts.offload-pool.* (#1558).

readonly idleTimeout: "actor-ts.offload-pool.idle-timeout" = 'actor-ts.offload-pool.idle-timeout'

readonly maxQueue: "actor-ts.offload-pool.max-queue" = 'actor-ts.offload-pool.max-queue'

readonly maxRestarts: "actor-ts.offload-pool.max-restarts" = 'actor-ts.offload-pool.max-restarts'

readonly minSize: "actor-ts.offload-pool.min-size" = 'actor-ts.offload-pool.min-size'

readonly overflow: "actor-ts.offload-pool.overflow" = 'actor-ts.offload-pool.overflow'

readonly restartWindow: "actor-ts.offload-pool.restart-window" = 'actor-ts.offload-pool.restart-window'

readonly size: "actor-ts.offload-pool.size" = 'actor-ts.offload-pool.size'

readonly taskTimeout: "actor-ts.offload-pool.task-timeout" = 'actor-ts.offload-pool.task-timeout'

readonly warmUp: "actor-ts.offload-pool.warm-up" = 'actor-ts.offload-pool.warm-up'

readonly parallelism: object

Actors on worker threads from configuration alone — actor-ts.parallelism.* (#1563).

readonly bufferSize: "actor-ts.parallelism.buffer-size" = 'actor-ts.parallelism.buffer-size'

readonly leader: "actor-ts.parallelism.leader" = 'actor-ts.parallelism.leader'

readonly offload: "actor-ts.parallelism.offload" = 'actor-ts.parallelism.offload'

readonly placement: "actor-ts.parallelism.placement" = 'actor-ts.parallelism.placement'

readonly spawnTimeout: "actor-ts.parallelism.spawn-timeout" = 'actor-ts.parallelism.spawn-timeout'

readonly workers: "actor-ts.parallelism.workers" = 'actor-ts.parallelism.workers'

readonly persistence: object

Persistence plugin selection + config — actor-ts.persistence.*.

readonly autoStart: "actor-ts.persistence.auto-start" = 'actor-ts.persistence.auto-start'

Whether the selected stores open in the startup’s persistence-start phase (#1473). One switch for all three axes rather than one per axis: what it moves is when a bad connection string fails, and a deployment that wants that failure at boot wants it for every store.

readonly durableState: object

The third plug-in axis (#872). It shipped as a namespace of ids nothing could select: PersistenceExtension carried only a journal and a snapshot-store registry, so durable-state.object-storage named a plugin that had to be threaded through application code by hand. plugin is the selector PersistenceExtension.durableStateStore resolves through, and DurableStateActor falls back to it when its options name no store.

readonly cloudflareD1: object

The Cloudflare D1 durable-state store’s block — see postgres.

persistence.durableState.cloudflareD1.accountId

Section titled “persistence.durableState.cloudflareD1.accountId”

readonly accountId: "actor-ts.persistence.durable-state.cloudflare-d1.account-id" = 'actor-ts.persistence.durable-state.cloudflare-d1.account-id'

persistence.durableState.cloudflareD1.apiToken

Section titled “persistence.durableState.cloudflareD1.apiToken”

readonly apiToken: "actor-ts.persistence.durable-state.cloudflare-d1.api-token" = 'actor-ts.persistence.durable-state.cloudflare-d1.api-token'

persistence.durableState.cloudflareD1.autoCreateTables

Section titled “persistence.durableState.cloudflareD1.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.durable-state.cloudflare-d1.auto-create-tables" = 'actor-ts.persistence.durable-state.cloudflare-d1.auto-create-tables'

persistence.durableState.cloudflareD1.baseUrl

Section titled “persistence.durableState.cloudflareD1.baseUrl”

readonly baseUrl: "actor-ts.persistence.durable-state.cloudflare-d1.base-url" = 'actor-ts.persistence.durable-state.cloudflare-d1.base-url'

persistence.durableState.cloudflareD1.databaseId

Section titled “persistence.durableState.cloudflareD1.databaseId”

readonly databaseId: "actor-ts.persistence.durable-state.cloudflare-d1.database-id" = 'actor-ts.persistence.durable-state.cloudflare-d1.database-id'

persistence.durableState.cloudflareD1.maxResponseBytes

Section titled “persistence.durableState.cloudflareD1.maxResponseBytes”

readonly maxResponseBytes: "actor-ts.persistence.durable-state.cloudflare-d1.max-response-bytes" = 'actor-ts.persistence.durable-state.cloudflare-d1.max-response-bytes'

persistence.durableState.cloudflareD1.root

Section titled “persistence.durableState.cloudflareD1.root”

readonly root: "actor-ts.persistence.durable-state.cloudflare-d1" = 'actor-ts.persistence.durable-state.cloudflare-d1'

persistence.durableState.cloudflareD1.table

Section titled “persistence.durableState.cloudflareD1.table”

readonly table: "actor-ts.persistence.durable-state.cloudflare-d1.table" = 'actor-ts.persistence.durable-state.cloudflare-d1.table'

persistence.durableState.cloudflareD1.timeout

Section titled “persistence.durableState.cloudflareD1.timeout”

readonly timeout: "actor-ts.persistence.durable-state.cloudflare-d1.timeout" = 'actor-ts.persistence.durable-state.cloudflare-d1.timeout'

readonly dynamodb: object

The DynamoDB durable-state store’s block - see journal’s dynamodb. There is no Cassandra sibling here at all: the tree ships no Cassandra durable-state store, so the “three stores per backend” model does not hold uniformly and this axis is two backends wide where the other two are three.

persistence.durableState.dynamodb.autoCreateTables

Section titled “persistence.durableState.dynamodb.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.durable-state.dynamodb.auto-create-tables" = 'actor-ts.persistence.durable-state.dynamodb.auto-create-tables'

persistence.durableState.dynamodb.billingMode

Section titled “persistence.durableState.dynamodb.billingMode”

readonly billingMode: "actor-ts.persistence.durable-state.dynamodb.billing-mode" = 'actor-ts.persistence.durable-state.dynamodb.billing-mode'

persistence.durableState.dynamodb.connectionTimeout

Section titled “persistence.durableState.dynamodb.connectionTimeout”

readonly connectionTimeout: "actor-ts.persistence.durable-state.dynamodb.connection-timeout" = 'actor-ts.persistence.durable-state.dynamodb.connection-timeout'

persistence.durableState.dynamodb.endpoint

Section titled “persistence.durableState.dynamodb.endpoint”

readonly endpoint: "actor-ts.persistence.durable-state.dynamodb.endpoint" = 'actor-ts.persistence.durable-state.dynamodb.endpoint'

persistence.durableState.dynamodb.maxAttempts

Section titled “persistence.durableState.dynamodb.maxAttempts”

readonly maxAttempts: "actor-ts.persistence.durable-state.dynamodb.max-attempts" = 'actor-ts.persistence.durable-state.dynamodb.max-attempts'

Comment-only, as are the three below — see journal’s dynamodb.

persistence.durableState.dynamodb.provisionedThroughputReadCapacityUnits

Section titled “persistence.durableState.dynamodb.provisionedThroughputReadCapacityUnits”

readonly provisionedThroughputReadCapacityUnits: "actor-ts.persistence.durable-state.dynamodb.provisioned-throughput.read-capacity-units" = 'actor-ts.persistence.durable-state.dynamodb.provisioned-throughput.read-capacity-units'

Comment-only, as is the write half — see journal’s dynamodb.

persistence.durableState.dynamodb.provisionedThroughputWriteCapacityUnits

Section titled “persistence.durableState.dynamodb.provisionedThroughputWriteCapacityUnits”

readonly provisionedThroughputWriteCapacityUnits: "actor-ts.persistence.durable-state.dynamodb.provisioned-throughput.write-capacity-units" = 'actor-ts.persistence.durable-state.dynamodb.provisioned-throughput.write-capacity-units'

readonly region: "actor-ts.persistence.durable-state.dynamodb.region" = 'actor-ts.persistence.durable-state.dynamodb.region'

persistence.durableState.dynamodb.requestTimeout

Section titled “persistence.durableState.dynamodb.requestTimeout”

readonly requestTimeout: "actor-ts.persistence.durable-state.dynamodb.request-timeout" = 'actor-ts.persistence.durable-state.dynamodb.request-timeout'

persistence.durableState.dynamodb.retryMode

Section titled “persistence.durableState.dynamodb.retryMode”

readonly retryMode: "actor-ts.persistence.durable-state.dynamodb.retry-mode" = 'actor-ts.persistence.durable-state.dynamodb.retry-mode'

readonly root: "actor-ts.persistence.durable-state.dynamodb" = 'actor-ts.persistence.durable-state.dynamodb'

readonly table: "actor-ts.persistence.durable-state.dynamodb.table" = 'actor-ts.persistence.durable-state.dynamodb.table'

persistence.durableState.dynamodb.tableReadyTimeout

Section titled “persistence.durableState.dynamodb.tableReadyTimeout”

readonly tableReadyTimeout: "actor-ts.persistence.durable-state.dynamodb.table-ready-timeout" = 'actor-ts.persistence.durable-state.dynamodb.table-ready-timeout'

readonly inMemory: "actor-ts.persistence.durable-state.in-memory" = 'actor-ts.persistence.durable-state.in-memory'

readonly libsql: object

The libSQL durable-state store’s block — see postgres.

readonly authToken: "actor-ts.persistence.durable-state.libsql.auth-token" = 'actor-ts.persistence.durable-state.libsql.auth-token'

persistence.durableState.libsql.autoCreateTables

Section titled “persistence.durableState.libsql.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.durable-state.libsql.auto-create-tables" = 'actor-ts.persistence.durable-state.libsql.auto-create-tables'

readonly root: "actor-ts.persistence.durable-state.libsql" = 'actor-ts.persistence.durable-state.libsql'

readonly table: "actor-ts.persistence.durable-state.libsql.table" = 'actor-ts.persistence.durable-state.libsql.table'

readonly url: "actor-ts.persistence.durable-state.libsql.url" = 'actor-ts.persistence.durable-state.libsql.url'

readonly mariadb: object

The MariaDB durable-state store’s block — see postgres.

persistence.durableState.mariadb.acquireTimeout

Section titled “persistence.durableState.mariadb.acquireTimeout”

readonly acquireTimeout: "actor-ts.persistence.durable-state.mariadb.acquire-timeout" = 'actor-ts.persistence.durable-state.mariadb.acquire-timeout'

persistence.durableState.mariadb.autoCreateTables

Section titled “persistence.durableState.mariadb.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.durable-state.mariadb.auto-create-tables" = 'actor-ts.persistence.durable-state.mariadb.auto-create-tables'

readonly caFile: "actor-ts.persistence.durable-state.mariadb.ca-file" = 'actor-ts.persistence.durable-state.mariadb.ca-file'

persistence.durableState.mariadb.connectTimeout

Section titled “persistence.durableState.mariadb.connectTimeout”

readonly connectTimeout: "actor-ts.persistence.durable-state.mariadb.connect-timeout" = 'actor-ts.persistence.durable-state.mariadb.connect-timeout'

persistence.durableState.mariadb.idleTimeout

Section titled “persistence.durableState.mariadb.idleTimeout”

readonly idleTimeout: "actor-ts.persistence.durable-state.mariadb.idle-timeout" = 'actor-ts.persistence.durable-state.mariadb.idle-timeout'

persistence.durableState.mariadb.maxPoolSize

Section titled “persistence.durableState.mariadb.maxPoolSize”

readonly maxPoolSize: "actor-ts.persistence.durable-state.mariadb.max-pool-size" = 'actor-ts.persistence.durable-state.mariadb.max-pool-size'

Comment-only, as are the four below — see journal’s mariadb.

readonly root: "actor-ts.persistence.durable-state.mariadb" = 'actor-ts.persistence.durable-state.mariadb'

readonly table: "actor-ts.persistence.durable-state.mariadb.table" = 'actor-ts.persistence.durable-state.mariadb.table'

readonly url: "actor-ts.persistence.durable-state.mariadb.url" = 'actor-ts.persistence.durable-state.mariadb.url'

readonly mongodb: object

The MongoDB durable-state store’s block - see journal’s mongodb.

readonly caFile: "actor-ts.persistence.durable-state.mongodb.ca-file" = 'actor-ts.persistence.durable-state.mongodb.ca-file'

persistence.durableState.mongodb.collection

Section titled “persistence.durableState.mongodb.collection”

readonly collection: "actor-ts.persistence.durable-state.mongodb.collection" = 'actor-ts.persistence.durable-state.mongodb.collection'

persistence.durableState.mongodb.connectTimeout

Section titled “persistence.durableState.mongodb.connectTimeout”

readonly connectTimeout: "actor-ts.persistence.durable-state.mongodb.connect-timeout" = 'actor-ts.persistence.durable-state.mongodb.connect-timeout'

persistence.durableState.mongodb.databaseName

Section titled “persistence.durableState.mongodb.databaseName”

readonly databaseName: "actor-ts.persistence.durable-state.mongodb.database-name" = 'actor-ts.persistence.durable-state.mongodb.database-name'

persistence.durableState.mongodb.maxPoolSize

Section titled “persistence.durableState.mongodb.maxPoolSize”

readonly maxPoolSize: "actor-ts.persistence.durable-state.mongodb.max-pool-size" = 'actor-ts.persistence.durable-state.mongodb.max-pool-size'

Comment-only, as are the four below — see journal’s mongodb.

persistence.durableState.mongodb.minPoolSize

Section titled “persistence.durableState.mongodb.minPoolSize”

readonly minPoolSize: "actor-ts.persistence.durable-state.mongodb.min-pool-size" = 'actor-ts.persistence.durable-state.mongodb.min-pool-size'

readonly root: "actor-ts.persistence.durable-state.mongodb" = 'actor-ts.persistence.durable-state.mongodb'

persistence.durableState.mongodb.serverSelectionTimeout

Section titled “persistence.durableState.mongodb.serverSelectionTimeout”

readonly serverSelectionTimeout: "actor-ts.persistence.durable-state.mongodb.server-selection-timeout" = 'actor-ts.persistence.durable-state.mongodb.server-selection-timeout'

readonly url: "actor-ts.persistence.durable-state.mongodb.url" = 'actor-ts.persistence.durable-state.mongodb.url'

readonly mssql: object

The SQL Server durable-state store’s block — see postgres.

persistence.durableState.mssql.autoCreateTables

Section titled “persistence.durableState.mssql.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.durable-state.mssql.auto-create-tables" = 'actor-ts.persistence.durable-state.mssql.auto-create-tables'

readonly caFile: "actor-ts.persistence.durable-state.mssql.ca-file" = 'actor-ts.persistence.durable-state.mssql.ca-file'

persistence.durableState.mssql.connectTimeout

Section titled “persistence.durableState.mssql.connectTimeout”

readonly connectTimeout: "actor-ts.persistence.durable-state.mssql.connect-timeout" = 'actor-ts.persistence.durable-state.mssql.connect-timeout'

persistence.durableState.mssql.idleTimeout

Section titled “persistence.durableState.mssql.idleTimeout”

readonly idleTimeout: "actor-ts.persistence.durable-state.mssql.idle-timeout" = 'actor-ts.persistence.durable-state.mssql.idle-timeout'

persistence.durableState.mssql.maxPoolSize

Section titled “persistence.durableState.mssql.maxPoolSize”

readonly maxPoolSize: "actor-ts.persistence.durable-state.mssql.max-pool-size" = 'actor-ts.persistence.durable-state.mssql.max-pool-size'

Comment-only, as are the four below — see journal’s mssql.

persistence.durableState.mssql.requestTimeout

Section titled “persistence.durableState.mssql.requestTimeout”

readonly requestTimeout: "actor-ts.persistence.durable-state.mssql.request-timeout" = 'actor-ts.persistence.durable-state.mssql.request-timeout'

readonly root: "actor-ts.persistence.durable-state.mssql" = 'actor-ts.persistence.durable-state.mssql'

readonly table: "actor-ts.persistence.durable-state.mssql.table" = 'actor-ts.persistence.durable-state.mssql.table'

readonly url: "actor-ts.persistence.durable-state.mssql.url" = 'actor-ts.persistence.durable-state.mssql.url'

readonly objectStorage: "actor-ts.persistence.durable-state.object-storage" = 'actor-ts.persistence.durable-state.object-storage'

readonly plugin: "actor-ts.persistence.durable-state.plugin" = 'actor-ts.persistence.durable-state.plugin'

readonly postgres: object

The five relational durable-state stores (#872, slice 2) — see journal’s postgres. These are the blocks that made the axis worth having beyond SQLite: each backend’s durable-state store is now a registered factory rather than an instance the register helper built eagerly and handed back, so the id here selects it.

persistence.durableState.postgres.autoCreateTables

Section titled “persistence.durableState.postgres.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.durable-state.postgres.auto-create-tables" = 'actor-ts.persistence.durable-state.postgres.auto-create-tables'

readonly caFile: "actor-ts.persistence.durable-state.postgres.ca-file" = 'actor-ts.persistence.durable-state.postgres.ca-file'

persistence.durableState.postgres.connectTimeout

Section titled “persistence.durableState.postgres.connectTimeout”

readonly connectTimeout: "actor-ts.persistence.durable-state.postgres.connect-timeout" = 'actor-ts.persistence.durable-state.postgres.connect-timeout'

persistence.durableState.postgres.idleTimeout

Section titled “persistence.durableState.postgres.idleTimeout”

readonly idleTimeout: "actor-ts.persistence.durable-state.postgres.idle-timeout" = 'actor-ts.persistence.durable-state.postgres.idle-timeout'

persistence.durableState.postgres.maxPoolSize

Section titled “persistence.durableState.postgres.maxPoolSize”

readonly maxPoolSize: "actor-ts.persistence.durable-state.postgres.max-pool-size" = 'actor-ts.persistence.durable-state.postgres.max-pool-size'

Comment-only, as are the three below — see journal’s postgres.

readonly root: "actor-ts.persistence.durable-state.postgres" = 'actor-ts.persistence.durable-state.postgres'

readonly table: "actor-ts.persistence.durable-state.postgres.table" = 'actor-ts.persistence.durable-state.postgres.table'

readonly url: "actor-ts.persistence.durable-state.postgres.url" = 'actor-ts.persistence.durable-state.postgres.url'

readonly sqlite: object

The SQLite durable-state store’s block — see journal’s sqlite.

persistence.durableState.sqlite.autoCreateTables

Section titled “persistence.durableState.sqlite.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.durable-state.sqlite.auto-create-tables" = 'actor-ts.persistence.durable-state.sqlite.auto-create-tables'

persistence.durableState.sqlite.busyTimeout

Section titled “persistence.durableState.sqlite.busyTimeout”

readonly busyTimeout: "actor-ts.persistence.durable-state.sqlite.busy-timeout" = 'actor-ts.persistence.durable-state.sqlite.busy-timeout'

readonly path: "actor-ts.persistence.durable-state.sqlite.path" = 'actor-ts.persistence.durable-state.sqlite.path'

readonly root: "actor-ts.persistence.durable-state.sqlite" = 'actor-ts.persistence.durable-state.sqlite'

readonly table: "actor-ts.persistence.durable-state.sqlite.table" = 'actor-ts.persistence.durable-state.sqlite.table'

readonly journal: object

readonly cassandra: object

The Cassandra / ScyllaDB journal’s block (#872, slice 3), and the widest of them: Cassandra is reached by a seed list rather than a URL, and its schema is four tables rather than one plus a derived name, because a wide-column store has no join to derive one with.

Full dotted leaves beside the root, which is also the plugin id CassandraPlugin.ts registers: the reader takes each leaf through its own accessor, rebased onto the block in force. That literal is no read, and NoDeadConfigKeys does not count it as one: the root only makes the leaves reachable, and each leaf is proven read by changing it and watching readCassandraJournalOptionsFromConfig’s answer (#1425). The substring search the gate replaced did count it — this block is the worked example #872’s triage cited.

consistency and serial-consistency are comment-only in reference.conf. Neither has a framework default - both read sites branch on === undefined - so absence is what leaves the level to the driver, and a published number would pin a choice the framework never made. credentials has no entry at all: it is key material, which never gets a path. replication is not free-form driver config but the typed shape keyspaceDdl validates, so it is read leaf by leaf: replication.class (kebab-case values mapped to CQL’s class names), replication.replication-factor and the comment-only replication.data-centers, a list of { name, replication-factor } entries rather than a map, because a data center’s name is the operator’s data, not a key (#1490).

readonly allIdsTable: "actor-ts.persistence.journal.cassandra.all-ids-table" = 'actor-ts.persistence.journal.cassandra.all-ids-table'

persistence.journal.cassandra.autoCreateKeyspace

Section titled “persistence.journal.cassandra.autoCreateKeyspace”

readonly autoCreateKeyspace: "actor-ts.persistence.journal.cassandra.auto-create-keyspace" = 'actor-ts.persistence.journal.cassandra.auto-create-keyspace'

persistence.journal.cassandra.autoCreateTables

Section titled “persistence.journal.cassandra.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.journal.cassandra.auto-create-tables" = 'actor-ts.persistence.journal.cassandra.auto-create-tables'

readonly consistency: "actor-ts.persistence.journal.cassandra.consistency" = 'actor-ts.persistence.journal.cassandra.consistency'

Comment-only in reference.conf - absence leaves the CQL level to the driver.

persistence.journal.cassandra.contactPoints

Section titled “persistence.journal.cassandra.contactPoints”

readonly contactPoints: "actor-ts.persistence.journal.cassandra.contact-points" = 'actor-ts.persistence.journal.cassandra.contact-points'

readonly eventsTable: "actor-ts.persistence.journal.cassandra.events-table" = 'actor-ts.persistence.journal.cassandra.events-table'

readonly keyspace: "actor-ts.persistence.journal.cassandra.keyspace" = 'actor-ts.persistence.journal.cassandra.keyspace'

persistence.journal.cassandra.lightweightTransactions

Section titled “persistence.journal.cassandra.lightweightTransactions”

readonly lightweightTransactions: "actor-ts.persistence.journal.cassandra.lightweight-transactions" = 'actor-ts.persistence.journal.cassandra.lightweight-transactions'

persistence.journal.cassandra.localDataCenter

Section titled “persistence.journal.cassandra.localDataCenter”

readonly localDataCenter: "actor-ts.persistence.journal.cassandra.local-data-center" = 'actor-ts.persistence.journal.cassandra.local-data-center'

persistence.journal.cassandra.metadataTable

Section titled “persistence.journal.cassandra.metadataTable”

readonly metadataTable: "actor-ts.persistence.journal.cassandra.metadata-table" = 'actor-ts.persistence.journal.cassandra.metadata-table'

persistence.journal.cassandra.partitionSize

Section titled “persistence.journal.cassandra.partitionSize”

readonly partitionSize: "actor-ts.persistence.journal.cassandra.partition-size" = 'actor-ts.persistence.journal.cassandra.partition-size'

readonly port: "actor-ts.persistence.journal.cassandra.port" = 'actor-ts.persistence.journal.cassandra.port'

persistence.journal.cassandra.replicationClass

Section titled “persistence.journal.cassandra.replicationClass”

readonly replicationClass: "actor-ts.persistence.journal.cassandra.replication.class" = 'actor-ts.persistence.journal.cassandra.replication.class'

persistence.journal.cassandra.replicationDataCenters

Section titled “persistence.journal.cassandra.replicationDataCenters”

readonly replicationDataCenters: "actor-ts.persistence.journal.cassandra.replication.data-centers" = 'actor-ts.persistence.journal.cassandra.replication.data-centers'

Comment-only in reference.conf - a list of { name, replication-factor } entries.

persistence.journal.cassandra.replicationFactor

Section titled “persistence.journal.cassandra.replicationFactor”

readonly replicationFactor: "actor-ts.persistence.journal.cassandra.replication.replication-factor" = 'actor-ts.persistence.journal.cassandra.replication.replication-factor'

readonly root: "actor-ts.persistence.journal.cassandra" = 'actor-ts.persistence.journal.cassandra'

persistence.journal.cassandra.serialConsistency

Section titled “persistence.journal.cassandra.serialConsistency”

readonly serialConsistency: "actor-ts.persistence.journal.cassandra.serial-consistency" = 'actor-ts.persistence.journal.cassandra.serial-consistency'

Comment-only in reference.conf - ignored unless the LWT above is on.

persistence.journal.cassandra.tagIndexTable

Section titled “persistence.journal.cassandra.tagIndexTable”

readonly tagIndexTable: "actor-ts.persistence.journal.cassandra.tag-index-table" = 'actor-ts.persistence.journal.cassandra.tag-index-table'

readonly useTagIndex: "actor-ts.persistence.journal.cassandra.use-tag-index" = 'actor-ts.persistence.journal.cassandra.use-tag-index'

readonly cloudflareD1: object

The Cloudflare D1 journal’s block — three coordinates, not a URL, and the two bounds of the HTTP transport D1 is the one backend to speak over: timeout and max-response-bytes (#1490).

persistence.journal.cloudflareD1.accountId

Section titled “persistence.journal.cloudflareD1.accountId”

readonly accountId: "actor-ts.persistence.journal.cloudflare-d1.account-id" = 'actor-ts.persistence.journal.cloudflare-d1.account-id'

readonly apiToken: "actor-ts.persistence.journal.cloudflare-d1.api-token" = 'actor-ts.persistence.journal.cloudflare-d1.api-token'

persistence.journal.cloudflareD1.autoCreateTables

Section titled “persistence.journal.cloudflareD1.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.journal.cloudflare-d1.auto-create-tables" = 'actor-ts.persistence.journal.cloudflare-d1.auto-create-tables'

readonly baseUrl: "actor-ts.persistence.journal.cloudflare-d1.base-url" = 'actor-ts.persistence.journal.cloudflare-d1.base-url'

persistence.journal.cloudflareD1.databaseId

Section titled “persistence.journal.cloudflareD1.databaseId”

readonly databaseId: "actor-ts.persistence.journal.cloudflare-d1.database-id" = 'actor-ts.persistence.journal.cloudflare-d1.database-id'

persistence.journal.cloudflareD1.eventsTable

Section titled “persistence.journal.cloudflareD1.eventsTable”

readonly eventsTable: "actor-ts.persistence.journal.cloudflare-d1.events-table" = 'actor-ts.persistence.journal.cloudflare-d1.events-table'

persistence.journal.cloudflareD1.maxResponseBytes

Section titled “persistence.journal.cloudflareD1.maxResponseBytes”

readonly maxResponseBytes: "actor-ts.persistence.journal.cloudflare-d1.max-response-bytes" = 'actor-ts.persistence.journal.cloudflare-d1.max-response-bytes'

readonly root: "actor-ts.persistence.journal.cloudflare-d1" = 'actor-ts.persistence.journal.cloudflare-d1'

persistence.journal.cloudflareD1.tagsTable

Section titled “persistence.journal.cloudflareD1.tagsTable”

readonly tagsTable: "actor-ts.persistence.journal.cloudflare-d1.tags-table" = 'actor-ts.persistence.journal.cloudflare-d1.tags-table'

readonly timeout: "actor-ts.persistence.journal.cloudflare-d1.timeout" = 'actor-ts.persistence.journal.cloudflare-d1.timeout'

readonly dynamodb: object

The DynamoDB journal’s block (#872, slice 3). Reached by a region and an optional endpoint override rather than a URL, and its table names carry the actor_ts_ prefix the store defaults to: a DynamoDB table name is account- and region-global, so the bare events the SQL family uses would collide with whatever else the account owns.

client-config has no entry, for the reason pool-config has none: it is the SDK’s whole option surface and stays the code-only long tail; nor do credentials, which reach the SDK through its own default chain. The client’s retry and timeout settings have typed leaves instead (#1490) — maxAttempts and the three after it, each comment-only in reference.conf, because unset leaves the SDK’s own resolution (an AWS_* environment variable, the shared config file) that a shipped value would overrule.

The table provisioning has leaves (#1490): billing-mode (kebab-case values the reader maps to AWS’s), table-ready-timeout, auto-create-tables, and the capacity pair under provisioned-throughput, which is comment-only — published, it would be refused for every store under the default pay-per-request mode.

persistence.journal.dynamodb.autoCreateTables

Section titled “persistence.journal.dynamodb.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.journal.dynamodb.auto-create-tables" = 'actor-ts.persistence.journal.dynamodb.auto-create-tables'

readonly billingMode: "actor-ts.persistence.journal.dynamodb.billing-mode" = 'actor-ts.persistence.journal.dynamodb.billing-mode'

persistence.journal.dynamodb.connectionTimeout

Section titled “persistence.journal.dynamodb.connectionTimeout”

readonly connectionTimeout: "actor-ts.persistence.journal.dynamodb.connection-timeout" = 'actor-ts.persistence.journal.dynamodb.connection-timeout'

readonly endpoint: "actor-ts.persistence.journal.dynamodb.endpoint" = 'actor-ts.persistence.journal.dynamodb.endpoint'

readonly eventsTable: "actor-ts.persistence.journal.dynamodb.events-table" = 'actor-ts.persistence.journal.dynamodb.events-table'

readonly maxAttempts: "actor-ts.persistence.journal.dynamodb.max-attempts" = 'actor-ts.persistence.journal.dynamodb.max-attempts'

Comment-only in reference.conf, as are the three below — see above.

persistence.journal.dynamodb.provisionedThroughputReadCapacityUnits

Section titled “persistence.journal.dynamodb.provisionedThroughputReadCapacityUnits”

readonly provisionedThroughputReadCapacityUnits: "actor-ts.persistence.journal.dynamodb.provisioned-throughput.read-capacity-units" = 'actor-ts.persistence.journal.dynamodb.provisioned-throughput.read-capacity-units'

Comment-only in reference.conf, as is the write half — see above.

persistence.journal.dynamodb.provisionedThroughputWriteCapacityUnits

Section titled “persistence.journal.dynamodb.provisionedThroughputWriteCapacityUnits”

readonly provisionedThroughputWriteCapacityUnits: "actor-ts.persistence.journal.dynamodb.provisioned-throughput.write-capacity-units" = 'actor-ts.persistence.journal.dynamodb.provisioned-throughput.write-capacity-units'

readonly region: "actor-ts.persistence.journal.dynamodb.region" = 'actor-ts.persistence.journal.dynamodb.region'

persistence.journal.dynamodb.requestTimeout

Section titled “persistence.journal.dynamodb.requestTimeout”

readonly requestTimeout: "actor-ts.persistence.journal.dynamodb.request-timeout" = 'actor-ts.persistence.journal.dynamodb.request-timeout'

readonly retryMode: "actor-ts.persistence.journal.dynamodb.retry-mode" = 'actor-ts.persistence.journal.dynamodb.retry-mode'

readonly root: "actor-ts.persistence.journal.dynamodb" = 'actor-ts.persistence.journal.dynamodb'

persistence.journal.dynamodb.tableReadyTimeout

Section titled “persistence.journal.dynamodb.tableReadyTimeout”

readonly tableReadyTimeout: "actor-ts.persistence.journal.dynamodb.table-ready-timeout" = 'actor-ts.persistence.journal.dynamodb.table-ready-timeout'

readonly inMemory: "actor-ts.persistence.journal.in-memory" = 'actor-ts.persistence.journal.in-memory'

readonly libsql: object

The libSQL journal’s block — auth-token is the Turso credential.

readonly authToken: "actor-ts.persistence.journal.libsql.auth-token" = 'actor-ts.persistence.journal.libsql.auth-token'

persistence.journal.libsql.autoCreateTables

Section titled “persistence.journal.libsql.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.journal.libsql.auto-create-tables" = 'actor-ts.persistence.journal.libsql.auto-create-tables'

readonly eventsTable: "actor-ts.persistence.journal.libsql.events-table" = 'actor-ts.persistence.journal.libsql.events-table'

readonly root: "actor-ts.persistence.journal.libsql" = 'actor-ts.persistence.journal.libsql'

readonly tagsTable: "actor-ts.persistence.journal.libsql.tags-table" = 'actor-ts.persistence.journal.libsql.tags-table'

readonly url: "actor-ts.persistence.journal.libsql.url" = 'actor-ts.persistence.journal.libsql.url'

readonly mariadb: object

The MariaDB journal’s block — see postgres.

persistence.journal.mariadb.acquireTimeout

Section titled “persistence.journal.mariadb.acquireTimeout”

readonly acquireTimeout: "actor-ts.persistence.journal.mariadb.acquire-timeout" = 'actor-ts.persistence.journal.mariadb.acquire-timeout'

persistence.journal.mariadb.autoCreateTables

Section titled “persistence.journal.mariadb.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.journal.mariadb.auto-create-tables" = 'actor-ts.persistence.journal.mariadb.auto-create-tables'

readonly caFile: "actor-ts.persistence.journal.mariadb.ca-file" = 'actor-ts.persistence.journal.mariadb.ca-file'

persistence.journal.mariadb.connectTimeout

Section titled “persistence.journal.mariadb.connectTimeout”

readonly connectTimeout: "actor-ts.persistence.journal.mariadb.connect-timeout" = 'actor-ts.persistence.journal.mariadb.connect-timeout'

readonly eventsTable: "actor-ts.persistence.journal.mariadb.events-table" = 'actor-ts.persistence.journal.mariadb.events-table'

readonly idleTimeout: "actor-ts.persistence.journal.mariadb.idle-timeout" = 'actor-ts.persistence.journal.mariadb.idle-timeout'

readonly maxPoolSize: "actor-ts.persistence.journal.mariadb.max-pool-size" = 'actor-ts.persistence.journal.mariadb.max-pool-size'

Comment-only in reference.conf, as are the four below — unset leaves the connector’s own default.

readonly root: "actor-ts.persistence.journal.mariadb" = 'actor-ts.persistence.journal.mariadb'

readonly tagsTable: "actor-ts.persistence.journal.mariadb.tags-table" = 'actor-ts.persistence.journal.mariadb.tags-table'

readonly url: "actor-ts.persistence.journal.mariadb.url" = 'actor-ts.persistence.journal.mariadb.url'

readonly mongodb: object

The MongoDB journal’s block (#872, slice 3). Mongo names its containers collections, so the leaf is events-collection rather than events-table and the switch is auto-create-indexes rather than auto-create-tables - the block says what the backend says, because a leaf named after another backend’s vocabulary is a leaf an operator has to translate.

client-options has no entry, for the reason pool-config has none: it is the driver’s whole option surface, free-form and unvalidated, and stays the code-only long tail. What an operator actually tunes on the client has typed leaves instead (#1490) — maxPoolSize and the four after it, each comment-only in reference.conf (unset leaves the driver’s own default) and validated by the store’s options validator.

persistence.journal.mongodb.autoCreateIndexes

Section titled “persistence.journal.mongodb.autoCreateIndexes”

readonly autoCreateIndexes: "actor-ts.persistence.journal.mongodb.auto-create-indexes" = 'actor-ts.persistence.journal.mongodb.auto-create-indexes'

readonly caFile: "actor-ts.persistence.journal.mongodb.ca-file" = 'actor-ts.persistence.journal.mongodb.ca-file'

persistence.journal.mongodb.connectTimeout

Section titled “persistence.journal.mongodb.connectTimeout”

readonly connectTimeout: "actor-ts.persistence.journal.mongodb.connect-timeout" = 'actor-ts.persistence.journal.mongodb.connect-timeout'

readonly databaseName: "actor-ts.persistence.journal.mongodb.database-name" = 'actor-ts.persistence.journal.mongodb.database-name'

persistence.journal.mongodb.eventsCollection

Section titled “persistence.journal.mongodb.eventsCollection”

readonly eventsCollection: "actor-ts.persistence.journal.mongodb.events-collection" = 'actor-ts.persistence.journal.mongodb.events-collection'

readonly maxPoolSize: "actor-ts.persistence.journal.mongodb.max-pool-size" = 'actor-ts.persistence.journal.mongodb.max-pool-size'

Comment-only in reference.conf, as are the four below — unset leaves the driver’s own default.

readonly minPoolSize: "actor-ts.persistence.journal.mongodb.min-pool-size" = 'actor-ts.persistence.journal.mongodb.min-pool-size'

readonly root: "actor-ts.persistence.journal.mongodb" = 'actor-ts.persistence.journal.mongodb'

persistence.journal.mongodb.serverSelectionTimeout

Section titled “persistence.journal.mongodb.serverSelectionTimeout”

readonly serverSelectionTimeout: "actor-ts.persistence.journal.mongodb.server-selection-timeout" = 'actor-ts.persistence.journal.mongodb.server-selection-timeout'

readonly url: "actor-ts.persistence.journal.mongodb.url" = 'actor-ts.persistence.journal.mongodb.url'

readonly mssql: object

The SQL Server journal’s block — see postgres.

persistence.journal.mssql.autoCreateTables

Section titled “persistence.journal.mssql.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.journal.mssql.auto-create-tables" = 'actor-ts.persistence.journal.mssql.auto-create-tables'

readonly caFile: "actor-ts.persistence.journal.mssql.ca-file" = 'actor-ts.persistence.journal.mssql.ca-file'

readonly connectTimeout: "actor-ts.persistence.journal.mssql.connect-timeout" = 'actor-ts.persistence.journal.mssql.connect-timeout'

readonly eventsTable: "actor-ts.persistence.journal.mssql.events-table" = 'actor-ts.persistence.journal.mssql.events-table'

readonly idleTimeout: "actor-ts.persistence.journal.mssql.idle-timeout" = 'actor-ts.persistence.journal.mssql.idle-timeout'

readonly maxPoolSize: "actor-ts.persistence.journal.mssql.max-pool-size" = 'actor-ts.persistence.journal.mssql.max-pool-size'

Comment-only in reference.conf, as are the four below — unset leaves node-mssql’s own default.

readonly requestTimeout: "actor-ts.persistence.journal.mssql.request-timeout" = 'actor-ts.persistence.journal.mssql.request-timeout'

readonly root: "actor-ts.persistence.journal.mssql" = 'actor-ts.persistence.journal.mssql'

readonly tagsTable: "actor-ts.persistence.journal.mssql.tags-table" = 'actor-ts.persistence.journal.mssql.tags-table'

readonly url: "actor-ts.persistence.journal.mssql.url" = 'actor-ts.persistence.journal.mssql.url'

readonly plugin: "actor-ts.persistence.journal.plugin" = 'actor-ts.persistence.journal.plugin'

readonly postgres: object

The five relational journals (#872, slice 2). They all sit on RelationalJournal, so the table half of every block is the same three leaves and only the connection half differs — which is why the leaf names are identical across them and the reader bodies are not.

tags-table is comment-only in reference.conf under every one of them: its default is derived from events-table (${events}_tags, RelationalJournal.ts), so absence is what selects it and a published value would pin the two apart the moment somebody renamed the event table. Comment-only, it is invisible to DocumentedDefaults, which pins published leaves — so it still needs this entry, a reader, and the unpublished-leaf entry through which the reader registry has NoDeadConfigKeys introduce it at one value, change it to a second, and require the reader to answer the two differently.

client / pool have no entry at all: they are live objects, so a config file cannot reach one. Nor has pool-config: it is the driver’s whole option surface, free-form and unvalidated, and stays the code-only long tail. What an operator actually tunes has typed leaves instead — postgres’s maxPoolSize and the three after it, mariadb’s five and mssql’s five — each comment-only in reference.conf (unset leaves the driver’s own default) and validated by the store’s options validator.

persistence.journal.postgres.autoCreateTables

Section titled “persistence.journal.postgres.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.journal.postgres.auto-create-tables" = 'actor-ts.persistence.journal.postgres.auto-create-tables'

readonly caFile: "actor-ts.persistence.journal.postgres.ca-file" = 'actor-ts.persistence.journal.postgres.ca-file'

persistence.journal.postgres.connectTimeout

Section titled “persistence.journal.postgres.connectTimeout”

readonly connectTimeout: "actor-ts.persistence.journal.postgres.connect-timeout" = 'actor-ts.persistence.journal.postgres.connect-timeout'

readonly eventsTable: "actor-ts.persistence.journal.postgres.events-table" = 'actor-ts.persistence.journal.postgres.events-table'

readonly idleTimeout: "actor-ts.persistence.journal.postgres.idle-timeout" = 'actor-ts.persistence.journal.postgres.idle-timeout'

readonly maxPoolSize: "actor-ts.persistence.journal.postgres.max-pool-size" = 'actor-ts.persistence.journal.postgres.max-pool-size'

Comment-only in reference.conf, as are the three below — unset leaves pg’s own default.

readonly root: "actor-ts.persistence.journal.postgres" = 'actor-ts.persistence.journal.postgres'

readonly tagsTable: "actor-ts.persistence.journal.postgres.tags-table" = 'actor-ts.persistence.journal.postgres.tags-table'

readonly url: "actor-ts.persistence.journal.postgres.url" = 'actor-ts.persistence.journal.postgres.url'

readonly sqlite: object

The SQLite journal’s block — root is also SQLITE_JOURNAL_PLUGIN_ID, per the framework rule that a plugin id is the config section holding that plugin’s settings (#872).

Full dotted leaves beside the root, which is also the plugin id SqlitePlugin.ts registers — the shape cassandra above explains. A plugin-id literal is no read of the block, and NoDeadConfigKeys does not take it for one: the root only makes the leaves reachable, and each leaf is proven read by changing it and watching the registered reader’s answer (#1425).

readonly busyTimeout: "actor-ts.persistence.journal.sqlite.busy-timeout" = 'actor-ts.persistence.journal.sqlite.busy-timeout'

readonly eventsTable: "actor-ts.persistence.journal.sqlite.events-table" = 'actor-ts.persistence.journal.sqlite.events-table'

readonly path: "actor-ts.persistence.journal.sqlite.path" = 'actor-ts.persistence.journal.sqlite.path'

readonly root: "actor-ts.persistence.journal.sqlite" = 'actor-ts.persistence.journal.sqlite'

readonly wal: "actor-ts.persistence.journal.sqlite.wal" = 'actor-ts.persistence.journal.sqlite.wal'

readonly journalBreaker: "actor-ts.persistence.journal-breaker" = 'actor-ts.persistence.journal-breaker'

The CircuitBreakerExtension id each store is called through — a name, not a block of numbers. The numbers live under actor-ts.circuit-breaker.<id>, which #864 made the single home for them; publishing max-failures a second time here would be two homes for one mechanism.

readonly maxConcurrentRecoveries: "actor-ts.persistence.max-concurrent-recoveries" = 'actor-ts.persistence.max-concurrent-recoveries'

System-wide persistence behaviour (#874), read once by PersistenceExtension — as distinct from the plugin-id namespaces below, which name another config root each.

These six sit directly under actor-ts.persistence, one level above where a plugin id can appear (persistence.<axis>.<backend>), so the “that block is exclusively plugin-id namespaces” reading that sent actor-ts.projection to the top level still holds for everything a backend owns.

Full dotted leaves rather than a block root: with no persistence root above them, NoDeadConfigKeys has to find each leaf here by its exact path, where one root would make every key under actor-ts.persistence reachable — every plugin block’s leaves and a misspelt one alike.

readonly recoveryTimeout: "actor-ts.persistence.recovery-timeout" = 'actor-ts.persistence.recovery-timeout'

readonly snapshotBreaker: "actor-ts.persistence.snapshot-breaker" = 'actor-ts.persistence.snapshot-breaker'

readonly snapshotIsOptional: "actor-ts.persistence.snapshot-is-optional" = 'actor-ts.persistence.snapshot-is-optional'

readonly snapshotStore: object

readonly cassandra: object

The Cassandra / ScyllaDB snapshot store’s block - see journal’s cassandra.

persistence.snapshotStore.cassandra.autoCreateKeyspace

Section titled “persistence.snapshotStore.cassandra.autoCreateKeyspace”

readonly autoCreateKeyspace: "actor-ts.persistence.snapshot-store.cassandra.auto-create-keyspace" = 'actor-ts.persistence.snapshot-store.cassandra.auto-create-keyspace'

persistence.snapshotStore.cassandra.autoCreateTables

Section titled “persistence.snapshotStore.cassandra.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.snapshot-store.cassandra.auto-create-tables" = 'actor-ts.persistence.snapshot-store.cassandra.auto-create-tables'

persistence.snapshotStore.cassandra.consistency

Section titled “persistence.snapshotStore.cassandra.consistency”

readonly consistency: "actor-ts.persistence.snapshot-store.cassandra.consistency" = 'actor-ts.persistence.snapshot-store.cassandra.consistency'

Comment-only in reference.conf - absence leaves the CQL level to the driver.

persistence.snapshotStore.cassandra.contactPoints

Section titled “persistence.snapshotStore.cassandra.contactPoints”

readonly contactPoints: "actor-ts.persistence.snapshot-store.cassandra.contact-points" = 'actor-ts.persistence.snapshot-store.cassandra.contact-points'

readonly keepN: "actor-ts.persistence.snapshot-store.cassandra.keep-n" = 'actor-ts.persistence.snapshot-store.cassandra.keep-n'

persistence.snapshotStore.cassandra.keyspace

Section titled “persistence.snapshotStore.cassandra.keyspace”

readonly keyspace: "actor-ts.persistence.snapshot-store.cassandra.keyspace" = 'actor-ts.persistence.snapshot-store.cassandra.keyspace'

persistence.snapshotStore.cassandra.localDataCenter

Section titled “persistence.snapshotStore.cassandra.localDataCenter”

readonly localDataCenter: "actor-ts.persistence.snapshot-store.cassandra.local-data-center" = 'actor-ts.persistence.snapshot-store.cassandra.local-data-center'

readonly port: "actor-ts.persistence.snapshot-store.cassandra.port" = 'actor-ts.persistence.snapshot-store.cassandra.port'

persistence.snapshotStore.cassandra.replicationClass

Section titled “persistence.snapshotStore.cassandra.replicationClass”

readonly replicationClass: "actor-ts.persistence.snapshot-store.cassandra.replication.class" = 'actor-ts.persistence.snapshot-store.cassandra.replication.class'

persistence.snapshotStore.cassandra.replicationDataCenters

Section titled “persistence.snapshotStore.cassandra.replicationDataCenters”

readonly replicationDataCenters: "actor-ts.persistence.snapshot-store.cassandra.replication.data-centers" = 'actor-ts.persistence.snapshot-store.cassandra.replication.data-centers'

Comment-only in reference.conf - a list of { name, replication-factor } entries.

persistence.snapshotStore.cassandra.replicationFactor

Section titled “persistence.snapshotStore.cassandra.replicationFactor”

readonly replicationFactor: "actor-ts.persistence.snapshot-store.cassandra.replication.replication-factor" = 'actor-ts.persistence.snapshot-store.cassandra.replication.replication-factor'

readonly root: "actor-ts.persistence.snapshot-store.cassandra" = 'actor-ts.persistence.snapshot-store.cassandra'

persistence.snapshotStore.cassandra.snapshotsTable

Section titled “persistence.snapshotStore.cassandra.snapshotsTable”

readonly snapshotsTable: "actor-ts.persistence.snapshot-store.cassandra.snapshots-table" = 'actor-ts.persistence.snapshot-store.cassandra.snapshots-table'

readonly cloudflareD1: object

The Cloudflare D1 snapshot store’s block — see postgres.

persistence.snapshotStore.cloudflareD1.accountId

Section titled “persistence.snapshotStore.cloudflareD1.accountId”

readonly accountId: "actor-ts.persistence.snapshot-store.cloudflare-d1.account-id" = 'actor-ts.persistence.snapshot-store.cloudflare-d1.account-id'

persistence.snapshotStore.cloudflareD1.apiToken

Section titled “persistence.snapshotStore.cloudflareD1.apiToken”

readonly apiToken: "actor-ts.persistence.snapshot-store.cloudflare-d1.api-token" = 'actor-ts.persistence.snapshot-store.cloudflare-d1.api-token'

persistence.snapshotStore.cloudflareD1.autoCreateTables

Section titled “persistence.snapshotStore.cloudflareD1.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.snapshot-store.cloudflare-d1.auto-create-tables" = 'actor-ts.persistence.snapshot-store.cloudflare-d1.auto-create-tables'

persistence.snapshotStore.cloudflareD1.baseUrl

Section titled “persistence.snapshotStore.cloudflareD1.baseUrl”

readonly baseUrl: "actor-ts.persistence.snapshot-store.cloudflare-d1.base-url" = 'actor-ts.persistence.snapshot-store.cloudflare-d1.base-url'

persistence.snapshotStore.cloudflareD1.databaseId

Section titled “persistence.snapshotStore.cloudflareD1.databaseId”

readonly databaseId: "actor-ts.persistence.snapshot-store.cloudflare-d1.database-id" = 'actor-ts.persistence.snapshot-store.cloudflare-d1.database-id'

persistence.snapshotStore.cloudflareD1.keepN

Section titled “persistence.snapshotStore.cloudflareD1.keepN”

readonly keepN: "actor-ts.persistence.snapshot-store.cloudflare-d1.keep-n" = 'actor-ts.persistence.snapshot-store.cloudflare-d1.keep-n'

persistence.snapshotStore.cloudflareD1.maxResponseBytes

Section titled “persistence.snapshotStore.cloudflareD1.maxResponseBytes”

readonly maxResponseBytes: "actor-ts.persistence.snapshot-store.cloudflare-d1.max-response-bytes" = 'actor-ts.persistence.snapshot-store.cloudflare-d1.max-response-bytes'

persistence.snapshotStore.cloudflareD1.root

Section titled “persistence.snapshotStore.cloudflareD1.root”

readonly root: "actor-ts.persistence.snapshot-store.cloudflare-d1" = 'actor-ts.persistence.snapshot-store.cloudflare-d1'

persistence.snapshotStore.cloudflareD1.snapshotsTable

Section titled “persistence.snapshotStore.cloudflareD1.snapshotsTable”

readonly snapshotsTable: "actor-ts.persistence.snapshot-store.cloudflare-d1.snapshots-table" = 'actor-ts.persistence.snapshot-store.cloudflare-d1.snapshots-table'

persistence.snapshotStore.cloudflareD1.timeout

Section titled “persistence.snapshotStore.cloudflareD1.timeout”

readonly timeout: "actor-ts.persistence.snapshot-store.cloudflare-d1.timeout" = 'actor-ts.persistence.snapshot-store.cloudflare-d1.timeout'

readonly dynamodb: object

The DynamoDB snapshot store’s block - see journal’s dynamodb.

persistence.snapshotStore.dynamodb.autoCreateTables

Section titled “persistence.snapshotStore.dynamodb.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.snapshot-store.dynamodb.auto-create-tables" = 'actor-ts.persistence.snapshot-store.dynamodb.auto-create-tables'

persistence.snapshotStore.dynamodb.billingMode

Section titled “persistence.snapshotStore.dynamodb.billingMode”

readonly billingMode: "actor-ts.persistence.snapshot-store.dynamodb.billing-mode" = 'actor-ts.persistence.snapshot-store.dynamodb.billing-mode'

persistence.snapshotStore.dynamodb.connectionTimeout

Section titled “persistence.snapshotStore.dynamodb.connectionTimeout”

readonly connectionTimeout: "actor-ts.persistence.snapshot-store.dynamodb.connection-timeout" = 'actor-ts.persistence.snapshot-store.dynamodb.connection-timeout'

persistence.snapshotStore.dynamodb.endpoint

Section titled “persistence.snapshotStore.dynamodb.endpoint”

readonly endpoint: "actor-ts.persistence.snapshot-store.dynamodb.endpoint" = 'actor-ts.persistence.snapshot-store.dynamodb.endpoint'

readonly keepN: "actor-ts.persistence.snapshot-store.dynamodb.keep-n" = 'actor-ts.persistence.snapshot-store.dynamodb.keep-n'

persistence.snapshotStore.dynamodb.maxAttempts

Section titled “persistence.snapshotStore.dynamodb.maxAttempts”

readonly maxAttempts: "actor-ts.persistence.snapshot-store.dynamodb.max-attempts" = 'actor-ts.persistence.snapshot-store.dynamodb.max-attempts'

Comment-only, as are the three below — see journal’s dynamodb.

persistence.snapshotStore.dynamodb.provisionedThroughputReadCapacityUnits

Section titled “persistence.snapshotStore.dynamodb.provisionedThroughputReadCapacityUnits”

readonly provisionedThroughputReadCapacityUnits: "actor-ts.persistence.snapshot-store.dynamodb.provisioned-throughput.read-capacity-units" = 'actor-ts.persistence.snapshot-store.dynamodb.provisioned-throughput.read-capacity-units'

Comment-only, as is the write half — see journal’s dynamodb.

persistence.snapshotStore.dynamodb.provisionedThroughputWriteCapacityUnits

Section titled “persistence.snapshotStore.dynamodb.provisionedThroughputWriteCapacityUnits”

readonly provisionedThroughputWriteCapacityUnits: "actor-ts.persistence.snapshot-store.dynamodb.provisioned-throughput.write-capacity-units" = 'actor-ts.persistence.snapshot-store.dynamodb.provisioned-throughput.write-capacity-units'

readonly region: "actor-ts.persistence.snapshot-store.dynamodb.region" = 'actor-ts.persistence.snapshot-store.dynamodb.region'

persistence.snapshotStore.dynamodb.requestTimeout

Section titled “persistence.snapshotStore.dynamodb.requestTimeout”

readonly requestTimeout: "actor-ts.persistence.snapshot-store.dynamodb.request-timeout" = 'actor-ts.persistence.snapshot-store.dynamodb.request-timeout'

persistence.snapshotStore.dynamodb.retryMode

Section titled “persistence.snapshotStore.dynamodb.retryMode”

readonly retryMode: "actor-ts.persistence.snapshot-store.dynamodb.retry-mode" = 'actor-ts.persistence.snapshot-store.dynamodb.retry-mode'

readonly root: "actor-ts.persistence.snapshot-store.dynamodb" = 'actor-ts.persistence.snapshot-store.dynamodb'

persistence.snapshotStore.dynamodb.snapshotsTable

Section titled “persistence.snapshotStore.dynamodb.snapshotsTable”

readonly snapshotsTable: "actor-ts.persistence.snapshot-store.dynamodb.snapshots-table" = 'actor-ts.persistence.snapshot-store.dynamodb.snapshots-table'

persistence.snapshotStore.dynamodb.tableReadyTimeout

Section titled “persistence.snapshotStore.dynamodb.tableReadyTimeout”

readonly tableReadyTimeout: "actor-ts.persistence.snapshot-store.dynamodb.table-ready-timeout" = 'actor-ts.persistence.snapshot-store.dynamodb.table-ready-timeout'

readonly inMemory: object

The in-memory snapshot store’s block - root is the plugin id PersistenceExtension installs when nothing is configured, and keep-n is its one leaf (#872, slice 3).

The only leaf outside the per-backend fan-out, and the store whose retention deliberately diverges: every persistent store keeps three snapshots per id, this one keeps all of them, because a default bound on the store an unconfigured application gets would quietly change what that application retains. The leaf is what lets a long-running fixture bound it without reaching for code.

readonly keepN: "actor-ts.persistence.snapshot-store.in-memory.keep-n" = 'actor-ts.persistence.snapshot-store.in-memory.keep-n'

readonly root: "actor-ts.persistence.snapshot-store.in-memory" = 'actor-ts.persistence.snapshot-store.in-memory'

readonly libsql: object

The libSQL snapshot store’s block — see postgres.

persistence.snapshotStore.libsql.authToken

Section titled “persistence.snapshotStore.libsql.authToken”

readonly authToken: "actor-ts.persistence.snapshot-store.libsql.auth-token" = 'actor-ts.persistence.snapshot-store.libsql.auth-token'

persistence.snapshotStore.libsql.autoCreateTables

Section titled “persistence.snapshotStore.libsql.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.snapshot-store.libsql.auto-create-tables" = 'actor-ts.persistence.snapshot-store.libsql.auto-create-tables'

readonly keepN: "actor-ts.persistence.snapshot-store.libsql.keep-n" = 'actor-ts.persistence.snapshot-store.libsql.keep-n'

readonly root: "actor-ts.persistence.snapshot-store.libsql" = 'actor-ts.persistence.snapshot-store.libsql'

persistence.snapshotStore.libsql.snapshotsTable

Section titled “persistence.snapshotStore.libsql.snapshotsTable”

readonly snapshotsTable: "actor-ts.persistence.snapshot-store.libsql.snapshots-table" = 'actor-ts.persistence.snapshot-store.libsql.snapshots-table'

readonly url: "actor-ts.persistence.snapshot-store.libsql.url" = 'actor-ts.persistence.snapshot-store.libsql.url'

readonly mariadb: object

The MariaDB snapshot store’s block — see postgres.

persistence.snapshotStore.mariadb.acquireTimeout

Section titled “persistence.snapshotStore.mariadb.acquireTimeout”

readonly acquireTimeout: "actor-ts.persistence.snapshot-store.mariadb.acquire-timeout" = 'actor-ts.persistence.snapshot-store.mariadb.acquire-timeout'

persistence.snapshotStore.mariadb.autoCreateTables

Section titled “persistence.snapshotStore.mariadb.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.snapshot-store.mariadb.auto-create-tables" = 'actor-ts.persistence.snapshot-store.mariadb.auto-create-tables'

readonly caFile: "actor-ts.persistence.snapshot-store.mariadb.ca-file" = 'actor-ts.persistence.snapshot-store.mariadb.ca-file'

persistence.snapshotStore.mariadb.connectTimeout

Section titled “persistence.snapshotStore.mariadb.connectTimeout”

readonly connectTimeout: "actor-ts.persistence.snapshot-store.mariadb.connect-timeout" = 'actor-ts.persistence.snapshot-store.mariadb.connect-timeout'

persistence.snapshotStore.mariadb.idleTimeout

Section titled “persistence.snapshotStore.mariadb.idleTimeout”

readonly idleTimeout: "actor-ts.persistence.snapshot-store.mariadb.idle-timeout" = 'actor-ts.persistence.snapshot-store.mariadb.idle-timeout'

readonly keepN: "actor-ts.persistence.snapshot-store.mariadb.keep-n" = 'actor-ts.persistence.snapshot-store.mariadb.keep-n'

persistence.snapshotStore.mariadb.maxPoolSize

Section titled “persistence.snapshotStore.mariadb.maxPoolSize”

readonly maxPoolSize: "actor-ts.persistence.snapshot-store.mariadb.max-pool-size" = 'actor-ts.persistence.snapshot-store.mariadb.max-pool-size'

Comment-only, as are the four below — see journal’s mariadb.

readonly root: "actor-ts.persistence.snapshot-store.mariadb" = 'actor-ts.persistence.snapshot-store.mariadb'

persistence.snapshotStore.mariadb.snapshotsTable

Section titled “persistence.snapshotStore.mariadb.snapshotsTable”

readonly snapshotsTable: "actor-ts.persistence.snapshot-store.mariadb.snapshots-table" = 'actor-ts.persistence.snapshot-store.mariadb.snapshots-table'

readonly url: "actor-ts.persistence.snapshot-store.mariadb.url" = 'actor-ts.persistence.snapshot-store.mariadb.url'

readonly mongodb: object

The MongoDB snapshot store’s block - see journal’s mongodb.

persistence.snapshotStore.mongodb.autoCreateIndexes

Section titled “persistence.snapshotStore.mongodb.autoCreateIndexes”

readonly autoCreateIndexes: "actor-ts.persistence.snapshot-store.mongodb.auto-create-indexes" = 'actor-ts.persistence.snapshot-store.mongodb.auto-create-indexes'

readonly caFile: "actor-ts.persistence.snapshot-store.mongodb.ca-file" = 'actor-ts.persistence.snapshot-store.mongodb.ca-file'

persistence.snapshotStore.mongodb.connectTimeout

Section titled “persistence.snapshotStore.mongodb.connectTimeout”

readonly connectTimeout: "actor-ts.persistence.snapshot-store.mongodb.connect-timeout" = 'actor-ts.persistence.snapshot-store.mongodb.connect-timeout'

persistence.snapshotStore.mongodb.databaseName

Section titled “persistence.snapshotStore.mongodb.databaseName”

readonly databaseName: "actor-ts.persistence.snapshot-store.mongodb.database-name" = 'actor-ts.persistence.snapshot-store.mongodb.database-name'

readonly keepN: "actor-ts.persistence.snapshot-store.mongodb.keep-n" = 'actor-ts.persistence.snapshot-store.mongodb.keep-n'

persistence.snapshotStore.mongodb.maxPoolSize

Section titled “persistence.snapshotStore.mongodb.maxPoolSize”

readonly maxPoolSize: "actor-ts.persistence.snapshot-store.mongodb.max-pool-size" = 'actor-ts.persistence.snapshot-store.mongodb.max-pool-size'

Comment-only, as are the four below — see journal’s mongodb.

persistence.snapshotStore.mongodb.minPoolSize

Section titled “persistence.snapshotStore.mongodb.minPoolSize”

readonly minPoolSize: "actor-ts.persistence.snapshot-store.mongodb.min-pool-size" = 'actor-ts.persistence.snapshot-store.mongodb.min-pool-size'

readonly root: "actor-ts.persistence.snapshot-store.mongodb" = 'actor-ts.persistence.snapshot-store.mongodb'

persistence.snapshotStore.mongodb.serverSelectionTimeout

Section titled “persistence.snapshotStore.mongodb.serverSelectionTimeout”

readonly serverSelectionTimeout: "actor-ts.persistence.snapshot-store.mongodb.server-selection-timeout" = 'actor-ts.persistence.snapshot-store.mongodb.server-selection-timeout'

persistence.snapshotStore.mongodb.snapshotsCollection

Section titled “persistence.snapshotStore.mongodb.snapshotsCollection”

readonly snapshotsCollection: "actor-ts.persistence.snapshot-store.mongodb.snapshots-collection" = 'actor-ts.persistence.snapshot-store.mongodb.snapshots-collection'

readonly url: "actor-ts.persistence.snapshot-store.mongodb.url" = 'actor-ts.persistence.snapshot-store.mongodb.url'

readonly mssql: object

The SQL Server snapshot store’s block — see postgres.

persistence.snapshotStore.mssql.autoCreateTables

Section titled “persistence.snapshotStore.mssql.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.snapshot-store.mssql.auto-create-tables" = 'actor-ts.persistence.snapshot-store.mssql.auto-create-tables'

readonly caFile: "actor-ts.persistence.snapshot-store.mssql.ca-file" = 'actor-ts.persistence.snapshot-store.mssql.ca-file'

persistence.snapshotStore.mssql.connectTimeout

Section titled “persistence.snapshotStore.mssql.connectTimeout”

readonly connectTimeout: "actor-ts.persistence.snapshot-store.mssql.connect-timeout" = 'actor-ts.persistence.snapshot-store.mssql.connect-timeout'

persistence.snapshotStore.mssql.idleTimeout

Section titled “persistence.snapshotStore.mssql.idleTimeout”

readonly idleTimeout: "actor-ts.persistence.snapshot-store.mssql.idle-timeout" = 'actor-ts.persistence.snapshot-store.mssql.idle-timeout'

readonly keepN: "actor-ts.persistence.snapshot-store.mssql.keep-n" = 'actor-ts.persistence.snapshot-store.mssql.keep-n'

persistence.snapshotStore.mssql.maxPoolSize

Section titled “persistence.snapshotStore.mssql.maxPoolSize”

readonly maxPoolSize: "actor-ts.persistence.snapshot-store.mssql.max-pool-size" = 'actor-ts.persistence.snapshot-store.mssql.max-pool-size'

Comment-only, as are the four below — see journal’s mssql.

persistence.snapshotStore.mssql.requestTimeout

Section titled “persistence.snapshotStore.mssql.requestTimeout”

readonly requestTimeout: "actor-ts.persistence.snapshot-store.mssql.request-timeout" = 'actor-ts.persistence.snapshot-store.mssql.request-timeout'

readonly root: "actor-ts.persistence.snapshot-store.mssql" = 'actor-ts.persistence.snapshot-store.mssql'

persistence.snapshotStore.mssql.snapshotsTable

Section titled “persistence.snapshotStore.mssql.snapshotsTable”

readonly snapshotsTable: "actor-ts.persistence.snapshot-store.mssql.snapshots-table" = 'actor-ts.persistence.snapshot-store.mssql.snapshots-table'

readonly url: "actor-ts.persistence.snapshot-store.mssql.url" = 'actor-ts.persistence.snapshot-store.mssql.url'

readonly objectStorage: object

The object-storage plugin’s block — the framework’s rule that a plugin id is its config section, so root is also OBJECT_STORAGE_SNAPSHOT_PLUGIN_ID (#873). It configures both stores registerObjectStoragePlugins returns, because the two share one backend; durableState.objectStorage below stays a bare plugin id and gets no leaves of its own.

Full dotted leaves beside the root, for the reason http.websocket spells out. The root is also the plugin id ObjectStoragePlugin.ts registers, which NoDeadConfigKeys does not mistake for a read of the block: it watches the registered reader’s answer as each leaf changes, not the source text (#1425).

No leaf carries key material, and that is structural rather than a convention: s3.credentials, the client-side master key and the integrity key have no path here at all, so a config file cannot express them.

persistence.snapshotStore.objectStorage.backend

Section titled “persistence.snapshotStore.objectStorage.backend”

readonly backend: "actor-ts.persistence.snapshot-store.object-storage.backend" = 'actor-ts.persistence.snapshot-store.object-storage.backend'

persistence.snapshotStore.objectStorage.compressionAlgorithm

Section titled “persistence.snapshotStore.objectStorage.compressionAlgorithm”

readonly compressionAlgorithm: "actor-ts.persistence.snapshot-store.object-storage.compression.algorithm" = 'actor-ts.persistence.snapshot-store.object-storage.compression.algorithm'

persistence.snapshotStore.objectStorage.compressionLevel

Section titled “persistence.snapshotStore.objectStorage.compressionLevel”

readonly compressionLevel: "actor-ts.persistence.snapshot-store.object-storage.compression.level" = 'actor-ts.persistence.snapshot-store.object-storage.compression.level'

Comment-only in reference.conf — absence selects the encoder’s per-algorithm default.

persistence.snapshotStore.objectStorage.encryptionKmsKeyId

Section titled “persistence.snapshotStore.objectStorage.encryptionKmsKeyId”

readonly encryptionKmsKeyId: "actor-ts.persistence.snapshot-store.object-storage.encryption.kms-key-id" = 'actor-ts.persistence.snapshot-store.object-storage.encryption.kms-key-id'

persistence.snapshotStore.objectStorage.encryptionMode

Section titled “persistence.snapshotStore.objectStorage.encryptionMode”

readonly encryptionMode: "actor-ts.persistence.snapshot-store.object-storage.encryption.mode" = 'actor-ts.persistence.snapshot-store.object-storage.encryption.mode'

persistence.snapshotStore.objectStorage.filesystemDir

Section titled “persistence.snapshotStore.objectStorage.filesystemDir”

readonly filesystemDir: "actor-ts.persistence.snapshot-store.object-storage.filesystem.dir" = 'actor-ts.persistence.snapshot-store.object-storage.filesystem.dir'

persistence.snapshotStore.objectStorage.filesystemLockTimeout

Section titled “persistence.snapshotStore.objectStorage.filesystemLockTimeout”

readonly filesystemLockTimeout: "actor-ts.persistence.snapshot-store.object-storage.filesystem.lock-timeout" = 'actor-ts.persistence.snapshot-store.object-storage.filesystem.lock-timeout'

persistence.snapshotStore.objectStorage.filesystemStaleLock

Section titled “persistence.snapshotStore.objectStorage.filesystemStaleLock”

readonly filesystemStaleLock: "actor-ts.persistence.snapshot-store.object-storage.filesystem.stale-lock" = 'actor-ts.persistence.snapshot-store.object-storage.filesystem.stale-lock'

persistence.snapshotStore.objectStorage.keepN

Section titled “persistence.snapshotStore.objectStorage.keepN”

readonly keepN: "actor-ts.persistence.snapshot-store.object-storage.keep-n" = 'actor-ts.persistence.snapshot-store.object-storage.keep-n'

persistence.snapshotStore.objectStorage.maxDecompressedBytes

Section titled “persistence.snapshotStore.objectStorage.maxDecompressedBytes”

readonly maxDecompressedBytes: "actor-ts.persistence.snapshot-store.object-storage.max-decompressed-bytes" = 'actor-ts.persistence.snapshot-store.object-storage.max-decompressed-bytes'

persistence.snapshotStore.objectStorage.prefix

Section titled “persistence.snapshotStore.objectStorage.prefix”

readonly prefix: "actor-ts.persistence.snapshot-store.object-storage.prefix" = 'actor-ts.persistence.snapshot-store.object-storage.prefix'

persistence.snapshotStore.objectStorage.root

Section titled “persistence.snapshotStore.objectStorage.root”

readonly root: "actor-ts.persistence.snapshot-store.object-storage" = 'actor-ts.persistence.snapshot-store.object-storage'

persistence.snapshotStore.objectStorage.s3Bucket

Section titled “persistence.snapshotStore.objectStorage.s3Bucket”

readonly s3Bucket: "actor-ts.persistence.snapshot-store.object-storage.s3.bucket" = 'actor-ts.persistence.snapshot-store.object-storage.s3.bucket'

persistence.snapshotStore.objectStorage.s3Endpoint

Section titled “persistence.snapshotStore.objectStorage.s3Endpoint”

readonly s3Endpoint: "actor-ts.persistence.snapshot-store.object-storage.s3.endpoint" = 'actor-ts.persistence.snapshot-store.object-storage.s3.endpoint'

persistence.snapshotStore.objectStorage.s3ForcePathStyle

Section titled “persistence.snapshotStore.objectStorage.s3ForcePathStyle”

readonly s3ForcePathStyle: "actor-ts.persistence.snapshot-store.object-storage.s3.force-path-style" = 'actor-ts.persistence.snapshot-store.object-storage.s3.force-path-style'

persistence.snapshotStore.objectStorage.s3Region

Section titled “persistence.snapshotStore.objectStorage.s3Region”

readonly s3Region: "actor-ts.persistence.snapshot-store.object-storage.s3.region" = 'actor-ts.persistence.snapshot-store.object-storage.s3.region'

readonly plugin: "actor-ts.persistence.snapshot-store.plugin" = 'actor-ts.persistence.snapshot-store.plugin'

readonly postgres: object

The five relational snapshot stores (#872, slice 2) — see journal’s postgres. The connection is repeated under each plugin root rather than hoisted to a per-backend one, because a plugin id is its config section: the three axes are selected independently and may legitimately name different databases. A deployment that does share one connection deduplicates it with a HOCON substitution.

persistence.snapshotStore.postgres.autoCreateTables

Section titled “persistence.snapshotStore.postgres.autoCreateTables”

readonly autoCreateTables: "actor-ts.persistence.snapshot-store.postgres.auto-create-tables" = 'actor-ts.persistence.snapshot-store.postgres.auto-create-tables'

readonly caFile: "actor-ts.persistence.snapshot-store.postgres.ca-file" = 'actor-ts.persistence.snapshot-store.postgres.ca-file'

persistence.snapshotStore.postgres.connectTimeout

Section titled “persistence.snapshotStore.postgres.connectTimeout”

readonly connectTimeout: "actor-ts.persistence.snapshot-store.postgres.connect-timeout" = 'actor-ts.persistence.snapshot-store.postgres.connect-timeout'

persistence.snapshotStore.postgres.idleTimeout

Section titled “persistence.snapshotStore.postgres.idleTimeout”

readonly idleTimeout: "actor-ts.persistence.snapshot-store.postgres.idle-timeout" = 'actor-ts.persistence.snapshot-store.postgres.idle-timeout'

readonly keepN: "actor-ts.persistence.snapshot-store.postgres.keep-n" = 'actor-ts.persistence.snapshot-store.postgres.keep-n'

persistence.snapshotStore.postgres.maxPoolSize

Section titled “persistence.snapshotStore.postgres.maxPoolSize”

readonly maxPoolSize: "actor-ts.persistence.snapshot-store.postgres.max-pool-size" = 'actor-ts.persistence.snapshot-store.postgres.max-pool-size'

Comment-only, as are the three below — see journal’s postgres.

readonly root: "actor-ts.persistence.snapshot-store.postgres" = 'actor-ts.persistence.snapshot-store.postgres'

persistence.snapshotStore.postgres.snapshotsTable

Section titled “persistence.snapshotStore.postgres.snapshotsTable”

readonly snapshotsTable: "actor-ts.persistence.snapshot-store.postgres.snapshots-table" = 'actor-ts.persistence.snapshot-store.postgres.snapshots-table'

readonly url: "actor-ts.persistence.snapshot-store.postgres.url" = 'actor-ts.persistence.snapshot-store.postgres.url'

readonly sqlite: object

The SQLite snapshot store’s block — see journal’s sqlite.

persistence.snapshotStore.sqlite.busyTimeout

Section titled “persistence.snapshotStore.sqlite.busyTimeout”

readonly busyTimeout: "actor-ts.persistence.snapshot-store.sqlite.busy-timeout" = 'actor-ts.persistence.snapshot-store.sqlite.busy-timeout'

readonly keepN: "actor-ts.persistence.snapshot-store.sqlite.keep-n" = 'actor-ts.persistence.snapshot-store.sqlite.keep-n'

readonly path: "actor-ts.persistence.snapshot-store.sqlite.path" = 'actor-ts.persistence.snapshot-store.sqlite.path'

readonly root: "actor-ts.persistence.snapshot-store.sqlite" = 'actor-ts.persistence.snapshot-store.sqlite'

persistence.snapshotStore.sqlite.snapshotsTable

Section titled “persistence.snapshotStore.sqlite.snapshotsTable”

readonly snapshotsTable: "actor-ts.persistence.snapshot-store.sqlite.snapshots-table" = 'actor-ts.persistence.snapshot-store.sqlite.snapshots-table'

readonly projection: object

Process-wide projection defaults — actor-ts.projection.*. Read by ProjectionActor.byPersistenceId / byTag, which layer them under the explicit ProjectionOptions of a single projection.

Top-level rather than under actor-ts.persistence.* because that block is exclusively plugin-id namespaces (journal.plugin names another config root), so a tuning leaf dropped in there reads as a plugin id. actor-ts.sharding is the same shape — a top-level block owned by a subdirectory subsystem.

Every leaf is spelled out rather than covered by a block root (#875): a root alone satisfies the NoDeadConfigKeys reachability check for everything beneath it, a misspelt leaf included.

groupAfterEnvelopes reaches handleGroup projections only; a handle projection has no group to size and ignores it (#1448).

readonly groupAfterEnvelopes: "actor-ts.projection.group-after-envelopes" = 'actor-ts.projection.group-after-envelopes'

readonly maxRetries: "actor-ts.projection.max-retries" = 'actor-ts.projection.max-retries'

readonly maxRetryBackoff: "actor-ts.projection.max-retry-backoff" = 'actor-ts.projection.max-retry-backoff'

readonly pollInterval: "actor-ts.projection.poll-interval" = 'actor-ts.projection.poll-interval'

readonly recoveryStrategy: "actor-ts.projection.recovery-strategy" = 'actor-ts.projection.recovery-strategy'

readonly retryBackoff: "actor-ts.projection.retry-backoff" = 'actor-ts.projection.retry-backoff'

readonly reliableDelivery: object

Reliable delivery — actor-ts.reliable-delivery.* (#861).

Every leaf is spelled out rather than covered by a block root, for the reason the two groups below it give: with no root above them, NoDeadConfigKeys has to find each leaf here by its exact path. The readers are readProducerControllerOptionsFromConfig (src/delivery/ProducerControllerOptions.ts) and readConsumerControllerOptionsFromConfig (src/delivery/ConsumerControllerOptions.ts), layered in ReliableDelivery.producer / .consumer.

The block is named for the ReliableDelivery class and the reliable-delivery.* message kinds on the wire, not for the src/delivery directory: actor-ts.logger.sinks.*.delivery.* is already taken by log-sink batching, with its own DeliveryOptions type and DEFAULT_DELIVERY_* constants, so a top-level actor-ts.delivery would collide in prose and in constant naming even though HOCON would keep the two apart.

producer-idle-time-to-live spells out the field’s Ttl, following cluster.tombstone.time-to-live ⇔ tombstoneTtlMs above — the same divergence from the leaf/field lockstep, and the same reason for it: the Ms suffix is carried by the HOCON duration unit and the abbreviation is one AGENTS.md asks to spell out.

consumer.max-out-of-order is the one leaf sized against another: producer.window-size sends are already in flight when a gap opens, so a cap below the largest window stalls that producer on its first gap. It ships at the same 1024 as max-producers, the bound the two halves of the deduplication budget share (#1471).

producer.producer-id deliberately has no key. It is a real options field, but one shared value across every producer in a process is the corruption Constants.ts documents — the consumer keys its deduplication on it, so two producers sharing an id reset each other’s window.

readonly consumer: object

readonly maxOutOfOrder: "actor-ts.reliable-delivery.consumer.max-out-of-order" = 'actor-ts.reliable-delivery.consumer.max-out-of-order'

readonly maxProducers: "actor-ts.reliable-delivery.consumer.max-producers" = 'actor-ts.reliable-delivery.consumer.max-producers'

reliableDelivery.consumer.producerIdleTimeToLive

Section titled “reliableDelivery.consumer.producerIdleTimeToLive”

readonly producerIdleTimeToLive: "actor-ts.reliable-delivery.consumer.producer-idle-time-to-live" = 'actor-ts.reliable-delivery.consumer.producer-idle-time-to-live'

readonly producer: object

readonly resendTimeout: "actor-ts.reliable-delivery.producer.resend-timeout" = 'actor-ts.reliable-delivery.producer.resend-timeout'

readonly windowSize: "actor-ts.reliable-delivery.producer.window-size" = 'actor-ts.reliable-delivery.producer.window-size'

readonly remote: object

Cluster addresses and wire limits — actor-ts.remote.*.

tcp.host and tcp.advertised-host are two different things and only one of them may be a wildcard: the first is the interface this node binds, the second is the address it puts in every gossip frame for peers to dial back (#944). advertised-host deliberately ships no leaf in reference.conf, so an unset one keeps meaning “derive it from tcp.host” instead of being permanently present and empty.

tcp.port and tcp.advertised-port are the same split one axis over (#845): the first is the port bound, the second the port peers dial, and the second likewise ships no leaf so that “the same as tcp.port” stays expressible. It is the published-container-port case — a process listening on 2552 that the outside world reaches on the port docker run -p 3000:2552 published — and nothing else needs it.

The bind pair ships no leaf either (#1435), for a precedence reason rather than an expressiveness one: on the bootstrapCluster path CLUSTER_HOST / POD_IP / HOSTNAME sit beneath tcp.host and CLUSTER_PORT beneath tcp.port, and a published value would occupy the config layer on every node and leave the variables unreachable — the trap discovery.kubernetes.namespace fell into. The built-in pair is DEFAULT_BIND_HOST / DEFAULT_PORT in ClusterOptions.ts, which the join applies beneath both.

remote.tls.enabled is read but not honoured: the transport Cluster builds for itself is always plaintext, so the flag decides nothing except whether the node warns about that at startup (#591). Encrypting the wire is its own issue (#941); until it lands, a key that says true and a socket that is not encrypted is exactly the gap the warning exists to close.

untrusted-mode and trusted-selection-paths narrow the one thing a remote party chooses — the to path on an inbound envelope (#877). They do not decide whether /system is reachable: that is refused unconditionally in EnvelopeTrust, because a switch defaulted off would leave #964 open on every deployment that did not opt in.

The last four are the transport’s association-lifecycle bounds, which have been enforced since #588 and #697 and only became configurable in #846. They are what an unauthenticated party can make this node hold: handshake-timeout reclaims a connection that never speaks its half of the handshake, incomplete-frame-idle reclaims one that went silent mid-frame, max-inbound-connections stops either cost from being multiplied by opening sockets in a loop, and outbound-queue-size bounds what this node holds for a peer that is not taking it.

handshake-timeout is deliberately one key rather than a dial/accept pair. The dialling side’s clock starts before the TCP connect and the TLS handshake and the accepting side’s starts after the accept, so equal numbers mean the peer that is still trying has always given up first; a split pair lets an operator set the acceptor stricter and make a healthy peer permanently unreachable.

connect-timeout is not that split: it bounds only how long a dial may take to open, under the handshake deadline that still bounds the whole dial, so a peer that is not there is known before a slow one is given up on (#1475). It ships comment-only, the tcp.advertised-host shape: unset means “the same as handshake-timeout”, and a shipped number would refuse every handshake-timeout set below it, since the connect deadline may not exceed the handshake one.

readonly connectTimeout: "actor-ts.remote.connect-timeout" = 'actor-ts.remote.connect-timeout'

readonly handshakeTimeout: "actor-ts.remote.handshake-timeout" = 'actor-ts.remote.handshake-timeout'

readonly incompleteFrameIdle: "actor-ts.remote.incomplete-frame-idle" = 'actor-ts.remote.incomplete-frame-idle'

readonly maxFrameBytes: "actor-ts.remote.max-frame-bytes" = 'actor-ts.remote.max-frame-bytes'

readonly maxInboundConnections: "actor-ts.remote.max-inbound-connections" = 'actor-ts.remote.max-inbound-connections'

readonly outboundQueueSize: "actor-ts.remote.outbound-queue-size" = 'actor-ts.remote.outbound-queue-size'

readonly tcp: object

readonly advertisedHost: "actor-ts.remote.tcp.advertised-host" = 'actor-ts.remote.tcp.advertised-host'

readonly advertisedPort: "actor-ts.remote.tcp.advertised-port" = 'actor-ts.remote.tcp.advertised-port'

readonly host: "actor-ts.remote.tcp.host" = 'actor-ts.remote.tcp.host'

readonly port: "actor-ts.remote.tcp.port" = 'actor-ts.remote.tcp.port'

readonly tls: object

readonly enabled: "actor-ts.remote.tls.enabled" = 'actor-ts.remote.tls.enabled'

readonly trustedSelectionPaths: "actor-ts.remote.trusted-selection-paths" = 'actor-ts.remote.trusted-selection-paths'

readonly untrustedMode: "actor-ts.remote.untrusted-mode" = 'actor-ts.remote.untrusted-mode'

readonly serialization: object

Decoder ceilings — actor-ts.serialization.read-constraints.* (#880).

Every leaf is declared individually rather than as a block root: NoDeadConfigKeys’ reachability check accepts a root above a leaf, so a single readConstraints entry would cover all three and any misspelt fourth, where declared individually each has to be named exactly. That each is read, the gate’s other half proves by changing it and watching readReadConstraintsOptionsFromConfig’s answer, whatever this file lists.

They bound READS only. The encoder keeps a hard MAX_NESTING_DEPTH, so lowering max-nesting-depth makes this node stricter than its own writer and raising it past the encoder’s cap is refused — a node that accepted what it cannot produce is the asymmetry #1036 closed.

readonly readConstraints: object

serialization.readConstraints.maxDocumentBytes

Section titled “serialization.readConstraints.maxDocumentBytes”

readonly maxDocumentBytes: "actor-ts.serialization.read-constraints.max-document-bytes" = 'actor-ts.serialization.read-constraints.max-document-bytes'

serialization.readConstraints.maxNestingDepth

Section titled “serialization.readConstraints.maxNestingDepth”

readonly maxNestingDepth: "actor-ts.serialization.read-constraints.max-nesting-depth" = 'actor-ts.serialization.read-constraints.max-nesting-depth'

serialization.readConstraints.maxStringLength

Section titled “serialization.readConstraints.maxStringLength”

readonly maxStringLength: "actor-ts.serialization.read-constraints.max-string-length" = 'actor-ts.serialization.read-constraints.max-string-length'

readonly shardedDaemonProcess: object

ShardedDaemonProcess.init defaults — actor-ts.sharded-daemon-process.* (#854). Read once per init and merged under the caller’s options, which is the seam the module had none of: it used to cast its argument straight to the settings type, so a daemon set was configurable from code and from nowhere else.

A top-level group rather than a nesting under ConfigKeys.sharding because a daemon set is a module built on sharding: sharding.* tunes every sharded type, these two tune only the daemons.

Both are full dotted paths rather than a shardedDaemonProcess block root, for the reason sharding.entityRecovery* above spells out: NoDeadConfigKeys resolves a leaf’s reachability through any config root above it, so a root-only entry would vouch for both whatever they were called.

name, numDaemons and actorFor have no leaf: they describe one daemon set, not a deployment, and a factory has no HOCON form at all.

readonly livenessInterval: "actor-ts.sharded-daemon-process.liveness-interval" = 'actor-ts.sharded-daemon-process.liveness-interval'

readonly role: "actor-ts.sharded-daemon-process.role" = 'actor-ts.sharded-daemon-process.role'

readonly sharding: object

Cluster-sharding defaults — actor-ts.sharding.*. Read once per started type by ClusterSharding.start, which layers them under the explicit options; most reach the region, rebalanceInterval and acquireRetryInterval and handOffTimeout the per-type coordinator, and shardRegionQueryTimeout neither — it is the default ClusterSharding.shards() / shardRefFor() wait, held on this node.

shardPassivationIdle has no leaf in reference.conf on purpose — it must stay absent for “unset means: follow passivationIdle” to be expressible, since a shipped value would make hasPath true forever.

bufferSize caps the region’s routing buffer as a region-wide total (#849). The buffer is keyed by shard id, so reading it as per-shard multiplies the bound by numberOfShards; and 0 here means never buffer, the opposite polarity to maxEntities = 0, which means no cap.

role names which role hosts a type; it does not give a node that role — actor-ts.cluster.roles does, and did not exist when this key shipped (#836). Which role hosts a type is uniform across a deployment — which roles a node carries is not — and that asymmetry is both the argument for the key and the reason it ships as "": the empty string is the only way a shipped leaf can still mean unrestricted, since reference.conf merges under everything and would otherwise make hasPath true forever (#847).

useLease gives every sharded type’s coordinator a lease built from actor-ts.coordination.lease (#847, #1454). With lease.backend = none the switch is refused when the type starts rather than producing no lease, which would advertise split-brain protection that is not there; an explicit withLease(…) wins over it. acquireRetryInterval paces the coordinator’s re-acquire() after a failed one, whichever way the lease arrived. There is no lease-name, and one written is refused: the name is derived per type, and one value for the block would put every type on one record.

The three entityRecovery* leaves pace how remembered entities come back after a region is handed a shard (#851). They are declared here as full dotted paths rather than as an entity-recovery block root on purpose: NoDeadConfigKeys’ reachability lookup falls back to any config root above a leaf, so a root-only entry would vouch for all three and any misspelt fourth, where declared each has to be named exactly. That each is read is the gate’s other half, proven by changing it and watching the registered reader’s answer (#1425).

entityRecoveryConstantRateNumberOfEntities is a region-wide budget, like bufferSize and maxEntities above and for the same reason: the recovery queue is fed by every shard the region owns, so read per shard the key would silently mean numberOfShards × what it says.

The two rebalance*Limit leaves bound shards in flight, not shards per tick, and they reach the coordinator rather than a strategy on purpose (#850): capping inside LeastShardAllocationStrategy — which already caps itself — would have left the default HashAllocationStrategy, and every user-supplied one, uncapped.

readonly acquireRetryInterval: "actor-ts.sharding.acquire-retry-interval" = 'actor-ts.sharding.acquire-retry-interval'

readonly bufferSize: "actor-ts.sharding.buffer-size" = 'actor-ts.sharding.buffer-size'

readonly coordinatorStateLoadTimeout: "actor-ts.sharding.coordinator-state-load-timeout" = 'actor-ts.sharding.coordinator-state-load-timeout'

sharding.entityRecoveryConstantRateFrequency

Section titled “sharding.entityRecoveryConstantRateFrequency”

readonly entityRecoveryConstantRateFrequency: "actor-ts.sharding.entity-recovery.constant-rate.frequency" = 'actor-ts.sharding.entity-recovery.constant-rate.frequency'

sharding.entityRecoveryConstantRateNumberOfEntities

Section titled “sharding.entityRecoveryConstantRateNumberOfEntities”

readonly entityRecoveryConstantRateNumberOfEntities: "actor-ts.sharding.entity-recovery.constant-rate.number-of-entities" = 'actor-ts.sharding.entity-recovery.constant-rate.number-of-entities'

readonly entityRecoveryStrategy: "actor-ts.sharding.entity-recovery.strategy" = 'actor-ts.sharding.entity-recovery.strategy'

readonly entityRestartBackoff: object

How long an entity that stopped without being passivated stays down before its shard re-creates it — actor-ts.sharding.entity-restart-backoff.* (#1437). The entity half of shardFailureBackoff above, in its shape and for its reasons: grouped in HOCON, flat in the options (entityRestartBackoffMinMs, …), and four full dotted leaves.

readonly max: "actor-ts.sharding.entity-restart-backoff.max" = 'actor-ts.sharding.entity-restart-backoff.max'

readonly min: "actor-ts.sharding.entity-restart-backoff.min" = 'actor-ts.sharding.entity-restart-backoff.min'

sharding.entityRestartBackoff.randomFactor

Section titled “sharding.entityRestartBackoff.randomFactor”

readonly randomFactor: "actor-ts.sharding.entity-restart-backoff.random-factor" = 'actor-ts.sharding.entity-restart-backoff.random-factor'

readonly resetAfter: "actor-ts.sharding.entity-restart-backoff.reset-after" = 'actor-ts.sharding.entity-restart-backoff.reset-after'

readonly handOffTimeout: "actor-ts.sharding.hand-off-timeout" = 'actor-ts.sharding.hand-off-timeout'

readonly healthcheck: object

The sharded types this node is not ready without — actor-ts.sharding.healthcheck.names (#1465). The one leaf of the block that is not read per started type: the Cluster constructor reads it once per join, and registerClusterHealthChecks installs a shardRegionRegistered readiness check per name beside the cluster’s own pair, so a type the node never starts keeps it out of rotation.

A full dotted leaf, not a healthcheck root, for the reason entity-recovery above spells out. Deliberately alone in its block: there is no timeout, because the check is a set read with nothing to wait for, and no window after which it stops failing, because a refused region is exactly what it has to keep reporting.

readonly names: "actor-ts.sharding.healthcheck.names" = 'actor-ts.sharding.healthcheck.names'

readonly maxEntities: "actor-ts.sharding.max-entities" = 'actor-ts.sharding.max-entities'

readonly numberOfShards: "actor-ts.sharding.number-of-shards" = 'actor-ts.sharding.number-of-shards'

readonly passivationAdmissionFilter: "actor-ts.sharding.passivation.admission-filter" = 'actor-ts.sharding.passivation.admission-filter'

sharding.passivationAdmissionWindowProportion

Section titled “sharding.passivationAdmissionWindowProportion”

readonly passivationAdmissionWindowProportion: "actor-ts.sharding.passivation.admission-window-proportion" = 'actor-ts.sharding.passivation.admission-window-proportion'

readonly passivationIdle: "actor-ts.sharding.passivation-idle" = 'actor-ts.sharding.passivation-idle'

readonly passivationReplacement: "actor-ts.sharding.passivation.replacement" = 'actor-ts.sharding.passivation.replacement'

Entity-replacement policy — actor-ts.sharding.passivation.* (#848). Grouped in HOCON because the five are only meaningful together and all five are inert without max-entities; the matching options fields stay flat (passivationReplacement, …), the same translation cluster.tombstone.* and stale-region-detection.* already make.

Full dotted leaves, not a bare passivation root, for the reason entity-recovery above spells out: NoDeadConfigKeys resolves a leaf’s reachability through any config root above it, so a root-only entry would vouch for all five whatever they were called.

passivation-idle and max-entities above deliberately do NOT move in here. Both are pinned as reference leaves at their current paths by the guards themselves, so relocating them means editing the tests that exist to catch relocation, and aliasing them means two leaves feeding one field with a precedence rule between them.

sharding.passivationSegmentedProtectedProportion

Section titled “sharding.passivationSegmentedProtectedProportion”

readonly passivationSegmentedProtectedProportion: "actor-ts.sharding.passivation.segmented-protected-proportion" = 'actor-ts.sharding.passivation.segmented-protected-proportion'

readonly passivationStopTimeout: "actor-ts.sharding.passivation.stop-timeout" = 'actor-ts.sharding.passivation.stop-timeout'

readonly persistCoordinatorState: "actor-ts.sharding.persist-coordinator-state" = 'actor-ts.sharding.persist-coordinator-state'

readonly rebalanceAbsoluteLimit: "actor-ts.sharding.rebalance-absolute-limit" = 'actor-ts.sharding.rebalance-absolute-limit'

readonly rebalanceInterval: "actor-ts.sharding.rebalance-interval" = 'actor-ts.sharding.rebalance-interval'

readonly rebalanceRelativeLimit: "actor-ts.sharding.rebalance-relative-limit" = 'actor-ts.sharding.rebalance-relative-limit'

readonly registerRetryInterval: "actor-ts.sharding.register-retry-interval" = 'actor-ts.sharding.register-retry-interval'

readonly rememberEntities: "actor-ts.sharding.remember-entities" = 'actor-ts.sharding.remember-entities'

readonly role: "actor-ts.sharding.role" = 'actor-ts.sharding.role'

readonly shardFailureBackoff: object

How long a shard that stopped unexpectedly stays down before its region re-creates it — actor-ts.sharding.shard-failure-backoff.* (#1437). Grouped in HOCON because the four describe one backoff; the matching options fields stay flat (shardFailureBackoffMinMs, …), the translation stale-region-detection.* above already makes.

Four full dotted leaves rather than a shardFailureBackoff root. NoDeadConfigKeys counts a leaf as read only when a registered reader answers differently once that leaf is perturbed, so a root can no longer carry an unread leaf through it — but the same guard decides whether a leaf is reachable from here by resolving it through any config root above it, and a root-only entry would vouch for leaves no accessor names.

readonly max: "actor-ts.sharding.shard-failure-backoff.max" = 'actor-ts.sharding.shard-failure-backoff.max'

readonly min: "actor-ts.sharding.shard-failure-backoff.min" = 'actor-ts.sharding.shard-failure-backoff.min'

readonly randomFactor: "actor-ts.sharding.shard-failure-backoff.random-factor" = 'actor-ts.sharding.shard-failure-backoff.random-factor'

readonly resetAfter: "actor-ts.sharding.shard-failure-backoff.reset-after" = 'actor-ts.sharding.shard-failure-backoff.reset-after'

readonly shardPassivationIdle: "actor-ts.sharding.shard-passivation-idle" = 'actor-ts.sharding.shard-passivation-idle'

readonly shardRegionQueryTimeout: "actor-ts.sharding.shard-region-query-timeout" = 'actor-ts.sharding.shard-region-query-timeout'

readonly staleRegionDetection: object

Stale-region detection — actor-ts.sharding.stale-region-detection.* (#853). Grouped in HOCON because the three are only meaningful together; the matching options fields stay flat (staleRegionDetection, regionHeartbeatIntervalMs, regionStaleAfterMs), the same translation cluster.tombstone.* already makes.

Full dotted leaves, not a bare staleRegionDetection root, and for the reason entity-recovery above spells out: NoDeadConfigKeys resolves a leaf’s reachability through any config root above it, so a root-only entry would vouch for all three whatever they were called.

readonly enabled: "actor-ts.sharding.stale-region-detection.enabled" = 'actor-ts.sharding.stale-region-detection.enabled'

sharding.staleRegionDetection.heartbeatInterval

Section titled “sharding.staleRegionDetection.heartbeatInterval”

readonly heartbeatInterval: "actor-ts.sharding.stale-region-detection.heartbeat-interval" = 'actor-ts.sharding.stale-region-detection.heartbeat-interval'

readonly staleAfter: "actor-ts.sharding.stale-region-detection.stale-after" = 'actor-ts.sharding.stale-region-detection.stale-after'

readonly useLease: "actor-ts.sharding.use-lease" = 'actor-ts.sharding.use-lease'

readonly system: object

ActorSystem identity and lifecycle — actor-ts.system.*.

readonly name: "actor-ts.system.name" = 'actor-ts.system.name'

readonly shutdownDrainTimeout: "actor-ts.system.shutdown-drain-timeout" = 'actor-ts.system.shutdown-drain-timeout'

readonly tracing: object

The OpenTelemetry tracer TracingExtension.enableOtel() builds, and the OpenTelemetry logger the ActorSystem constructor builds from the otelLogs slot — actor-ts.tracing.* (#1466). readOtelAdapterOptionsFromConfig supplies the name and version the tracer asks getTracer for, readOtelLogsAdapterOptionsFromConfig the pair the logger asks getLogger for, each layered under its explicit options; the free otelTracer and otelLogger take no config and stay the pure code paths.

The @opentelemetry/api and @opentelemetry/api-logs namespaces and a pre-built tracer or logger have no path and cannot get one: all are live objects, which HOCON has no way to express.

Every leaf is spelled out rather than covered by a block root: a root alone satisfies the NoDeadConfigKeys reachability check for everything beneath it.

readonly loggerName: "actor-ts.tracing.logger-name" = 'actor-ts.tracing.logger-name'

readonly loggerVersion: "actor-ts.tracing.logger-version" = 'actor-ts.tracing.logger-version'

Comment-only in reference.conf — unset passes no version to getLogger.

readonly tracerName: "actor-ts.tracing.tracer-name" = 'actor-ts.tracing.tracer-name'

readonly tracerVersion: "actor-ts.tracing.tracer-version" = 'actor-ts.tracing.tracer-version'

Comment-only in reference.conf — unset passes no version to getTracer.

readonly worker: object

Worker IPC sentinels — used by the multi-runtime test harness and the worker-mesh code. Unlike the config paths above, these are message-kind strings, so they intentionally drop the actor-ts. prefix — wire-format discriminators don’t need a framework namespace.

readonly hello: "worker-hello" = 'worker-hello'

readonly init: "worker-init" = 'worker-init'

readonly ready: "worker-ready" = 'worker-ready'

readonly transport: "worker-transport" = 'worker-transport'

readonly workerCluster: object

WorkerCluster.spawn defaults — actor-ts.worker-cluster.*.

The block is named after the options type it feeds rather than after “worker”, both because that is what it configures and because ConfigKeys.worker below is already taken by the IPC sentinels, which are not config paths at all.

readonly basePort: "actor-ts.worker-cluster.base-port" = 'actor-ts.worker-cluster.base-port'

readonly hostname: "actor-ts.worker-cluster.hostname" = 'actor-ts.worker-cluster.hostname'

readonly maxRestarts: "actor-ts.worker-cluster.max-restarts" = 'actor-ts.worker-cluster.max-restarts'

readonly readyTimeout: "actor-ts.worker-cluster.ready-timeout" = 'actor-ts.worker-cluster.ready-timeout'

readonly restartMaxBackoff: "actor-ts.worker-cluster.restart-max-backoff" = 'actor-ts.worker-cluster.restart-max-backoff'

readonly restartMinBackoff: "actor-ts.worker-cluster.restart-min-backoff" = 'actor-ts.worker-cluster.restart-min-backoff'

readonly restartPolicy: "actor-ts.worker-cluster.restart-policy" = 'actor-ts.worker-cluster.restart-policy'

readonly restartRandomFactor: "actor-ts.worker-cluster.restart-random-factor" = 'actor-ts.worker-cluster.restart-random-factor'

readonly restartWindow: "actor-ts.worker-cluster.restart-window" = 'actor-ts.worker-cluster.restart-window'

readonly systemName: "actor-ts.worker-cluster.system-name" = 'actor-ts.worker-cluster.system-name'

readonly workers: "actor-ts.worker-cluster.workers" = 'actor-ts.worker-cluster.workers'

readonly workerMesh: object

actor-ts.worker-mesh.* — the main thread joining its own workers (#1562). The actor module and the bootstrap are deliberately absent, as worker-cluster.bootstrap is: a config file must not decide which code a worker runs. The restart knobs are worker-cluster.*’s and are read there.

readonly basePort: "actor-ts.worker-mesh.base-port" = 'actor-ts.worker-mesh.base-port'

readonly mainHostname: "actor-ts.worker-mesh.main-hostname" = 'actor-ts.worker-mesh.main-hostname'

readonly mainPort: "actor-ts.worker-mesh.main-port" = 'actor-ts.worker-mesh.main-port'

readonly mainRoles: "actor-ts.worker-mesh.main-roles" = 'actor-ts.worker-mesh.main-roles'

readonly metricsRelayInterval: "actor-ts.worker-mesh.metrics-relay-interval" = 'actor-ts.worker-mesh.metrics-relay-interval'

readonly workerHostname: "actor-ts.worker-mesh.worker-hostname" = 'actor-ts.worker-mesh.worker-hostname'

readonly workerRoles: "actor-ts.worker-mesh.worker-roles" = 'actor-ts.worker-mesh.worker-roles'

readonly workers: "actor-ts.worker-mesh.workers" = 'actor-ts.worker-mesh.workers'