ConfigKeys
Este conteúdo não está disponível em sua língua ainda.
constConfigKeys: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:
-
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.rootis a typed reference — IDE autocomplete + TypeScript catch typos before they ship. -
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.
Type Declaration
Section titled “Type Declaration”
readonlyactor: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.
actor.askTimeout
Section titled “actor.askTimeout”
readonlyaskTimeout:"actor-ts.actor.ask-timeout"='actor-ts.actor.ask-timeout'
actor.throughput
Section titled “actor.throughput”
readonlythroughput:"actor-ts.actor.throughput"='actor-ts.actor.throughput'
backoffSupervisor
Section titled “backoffSupervisor”
readonlybackoffSupervisor: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.
backoffSupervisor.drainGrace
Section titled “backoffSupervisor.drainGrace”
readonlydrainGrace:"actor-ts.backoff-supervisor.drain-grace"='actor-ts.backoff-supervisor.drain-grace'
auto (min(50ms, min-backoff), resolved per supervisor) | a duration.
backoffSupervisor.forward
Section titled “backoffSupervisor.forward”
readonlyforward:"actor-ts.backoff-supervisor.forward"='actor-ts.backoff-supervisor.forward'
backoffSupervisor.forwardDuringGrace
Section titled “backoffSupervisor.forwardDuringGrace”
readonlyforwardDuringGrace:"actor-ts.backoff-supervisor.forward-during-grace"='actor-ts.backoff-supervisor.forward-during-grace'
backoffSupervisor.maxBackoff
Section titled “backoffSupervisor.maxBackoff”
readonlymaxBackoff:"actor-ts.backoff-supervisor.max-backoff"='actor-ts.backoff-supervisor.max-backoff'
backoffSupervisor.maxStashSize
Section titled “backoffSupervisor.maxStashSize”
readonlymaxStashSize:"actor-ts.backoff-supervisor.max-stash-size"='actor-ts.backoff-supervisor.max-stash-size'
backoffSupervisor.minBackoff
Section titled “backoffSupervisor.minBackoff”
readonlyminBackoff:"actor-ts.backoff-supervisor.min-backoff"='actor-ts.backoff-supervisor.min-backoff'
backoffSupervisor.randomFactor
Section titled “backoffSupervisor.randomFactor”
readonlyrandomFactor:"actor-ts.backoff-supervisor.random-factor"='actor-ts.backoff-supervisor.random-factor'
backoffSupervisor.resetCounter
Section titled “backoffSupervisor.resetCounter”
readonlyresetCounter:"actor-ts.backoff-supervisor.reset-counter"='actor-ts.backoff-supervisor.reset-counter'
never | after-min-stable | a duration for the after-time variant.
backoffSupervisor.triggerOn
Section titled “backoffSupervisor.triggerOn”
readonlytriggerOn:"actor-ts.backoff-supervisor.trigger-on"='actor-ts.backoff-supervisor.trigger-on'
readonlycache:object
Cache plugin-ids — actor-ts.cache.*.
cache.inMemory
Section titled “cache.inMemory”
readonlyinMemory:"actor-ts.cache.in-memory"='actor-ts.cache.in-memory'
cache.inMemoryOptions
Section titled “cache.inMemoryOptions”
readonlyinMemoryOptions: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).
cache.inMemoryOptions.cleanupInterval
Section titled “cache.inMemoryOptions.cleanupInterval”
readonlycleanupInterval:"actor-ts.cache.in-memory.cleanup-interval"='actor-ts.cache.in-memory.cleanup-interval'
cache.inMemoryOptions.maxEntries
Section titled “cache.inMemoryOptions.maxEntries”
readonlymaxEntries:"actor-ts.cache.in-memory.max-entries"='actor-ts.cache.in-memory.max-entries'
cache.inMemoryOptions.prefixQuotas
Section titled “cache.inMemoryOptions.prefixQuotas”
readonlyprefixQuotas:"actor-ts.cache.in-memory.prefix-quotas"='actor-ts.cache.in-memory.prefix-quotas'
Comment-only in reference.conf — unset means one undivided map.
cache.inMemoryOptions.root
Section titled “cache.inMemoryOptions.root”
readonlyroot:"actor-ts.cache.in-memory"='actor-ts.cache.in-memory'
cache.inMemoryOptions.timeToIdle
Section titled “cache.inMemoryOptions.timeToIdle”
readonlytimeToIdle:"actor-ts.cache.in-memory.time-to-idle"='actor-ts.cache.in-memory.time-to-idle'
cache.inMemoryOptions.timeToLive
Section titled “cache.inMemoryOptions.timeToLive”
readonlytimeToLive:"actor-ts.cache.in-memory.time-to-live"='actor-ts.cache.in-memory.time-to-live'
cache.memcached
Section titled “cache.memcached”
readonlymemcached:"actor-ts.cache.memcached"='actor-ts.cache.memcached'
cache.memcachedOptions
Section titled “cache.memcachedOptions”
readonlymemcachedOptions:object
The global Memcached block’s settings — see redisOptions.
cache.memcachedOptions.keyPrefix
Section titled “cache.memcachedOptions.keyPrefix”
readonlykeyPrefix:"actor-ts.cache.memcached.key-prefix"='actor-ts.cache.memcached.key-prefix'
cache.memcachedOptions.password
Section titled “cache.memcachedOptions.password”
readonlypassword:"actor-ts.cache.memcached.password"='actor-ts.cache.memcached.password'
cache.memcachedOptions.root
Section titled “cache.memcachedOptions.root”
readonlyroot:"actor-ts.cache.memcached"='actor-ts.cache.memcached'
cache.memcachedOptions.servers
Section titled “cache.memcachedOptions.servers”
readonlyservers:"actor-ts.cache.memcached.servers"='actor-ts.cache.memcached.servers'
cache.memcachedOptions.username
Section titled “cache.memcachedOptions.username”
readonlyusername:"actor-ts.cache.memcached.username"='actor-ts.cache.memcached.username'
cache.redis
Section titled “cache.redis”
readonlyredis:"actor-ts.cache.redis"='actor-ts.cache.redis'
cache.redisOptions
Section titled “cache.redisOptions”
readonlyredisOptions: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.
cache.redisOptions.db
Section titled “cache.redisOptions.db”
readonlydb:"actor-ts.cache.redis.db"='actor-ts.cache.redis.db'
cache.redisOptions.host
Section titled “cache.redisOptions.host”
readonlyhost:"actor-ts.cache.redis.host"='actor-ts.cache.redis.host'
cache.redisOptions.keyPrefix
Section titled “cache.redisOptions.keyPrefix”
readonlykeyPrefix:"actor-ts.cache.redis.key-prefix"='actor-ts.cache.redis.key-prefix'
cache.redisOptions.password
Section titled “cache.redisOptions.password”
readonlypassword:"actor-ts.cache.redis.password"='actor-ts.cache.redis.password'
cache.redisOptions.port
Section titled “cache.redisOptions.port”
readonlyport:"actor-ts.cache.redis.port"='actor-ts.cache.redis.port'
cache.redisOptions.root
Section titled “cache.redisOptions.root”
readonlyroot:"actor-ts.cache.redis"='actor-ts.cache.redis'
cache.redisOptions.url
Section titled “cache.redisOptions.url”
readonlyurl:"actor-ts.cache.redis.url"='actor-ts.cache.redis.url'
cache.root
Section titled “cache.root”
readonlyroot:"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.
circuitBreaker
Section titled “circuitBreaker”
readonlycircuitBreaker: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).
circuitBreaker.default
Section titled “circuitBreaker.default”
readonlydefault:object
circuitBreaker.default.backoffFactor
Section titled “circuitBreaker.default.backoffFactor”
readonlybackoffFactor:"actor-ts.circuit-breaker.default.backoff-factor"='actor-ts.circuit-breaker.default.backoff-factor'
circuitBreaker.default.callTimeout
Section titled “circuitBreaker.default.callTimeout”
readonlycallTimeout:"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.
circuitBreaker.default.ignoredErrorNames
Section titled “circuitBreaker.default.ignoredErrorNames”
readonlyignoredErrorNames:"actor-ts.circuit-breaker.default.ignored-error-names"='actor-ts.circuit-breaker.default.ignored-error-names'
circuitBreaker.default.maxFailures
Section titled “circuitBreaker.default.maxFailures”
readonlymaxFailures:"actor-ts.circuit-breaker.default.max-failures"='actor-ts.circuit-breaker.default.max-failures'
circuitBreaker.default.maxResetTimeout
Section titled “circuitBreaker.default.maxResetTimeout”
readonlymaxResetTimeout:"actor-ts.circuit-breaker.default.max-reset-timeout"='actor-ts.circuit-breaker.default.max-reset-timeout'
circuitBreaker.default.randomFactor
Section titled “circuitBreaker.default.randomFactor”
readonlyrandomFactor:"actor-ts.circuit-breaker.default.random-factor"='actor-ts.circuit-breaker.default.random-factor'
circuitBreaker.default.resetTimeout
Section titled “circuitBreaker.default.resetTimeout”
readonlyresetTimeout:"actor-ts.circuit-breaker.default.reset-timeout"='actor-ts.circuit-breaker.default.reset-timeout'
circuitBreaker.root
Section titled “circuitBreaker.root”
readonlyroot:"actor-ts.circuit-breaker"='actor-ts.circuit-breaker'
cluster
Section titled “cluster”
readonlycluster: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.
cluster.appVersion
Section titled “cluster.appVersion”
readonlyappVersion:"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.
cluster.bootstrap
Section titled “cluster.bootstrap”
readonlybootstrap: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).
cluster.bootstrap.awaitReady
Section titled “cluster.bootstrap.awaitReady”
readonlyawaitReady:"actor-ts.cluster.bootstrap.await-ready"='actor-ts.cluster.bootstrap.await-ready'
cluster.bootstrap.discovery
Section titled “cluster.bootstrap.discovery”
readonlydiscovery: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.
cluster.bootstrap.discovery.method
Section titled “cluster.bootstrap.discovery.method”
readonlymethod:"actor-ts.cluster.bootstrap.discovery.method"='actor-ts.cluster.bootstrap.discovery.method'
cluster.bootstrap.discovery.serviceName
Section titled “cluster.bootstrap.discovery.serviceName”
readonlyserviceName:"actor-ts.cluster.bootstrap.discovery.service-name"='actor-ts.cluster.bootstrap.discovery.service-name'
cluster.bootstrap.maxWait
Section titled “cluster.bootstrap.maxWait”
readonlymaxWait:"actor-ts.cluster.bootstrap.max-wait"='actor-ts.cluster.bootstrap.max-wait'
cluster.bootstrap.minimumMembers
Section titled “cluster.bootstrap.minimumMembers”
readonlyminimumMembers:"actor-ts.cluster.bootstrap.minimum-members"='actor-ts.cluster.bootstrap.minimum-members'
cluster.bootstrap.newClusterEnabled
Section titled “cluster.bootstrap.newClusterEnabled”
readonlynewClusterEnabled:"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.
cluster.bootstrap.pollInterval
Section titled “cluster.bootstrap.pollInterval”
readonlypollInterval:"actor-ts.cluster.bootstrap.poll-interval"='actor-ts.cluster.bootstrap.poll-interval'
cluster.bootstrap.requiredContactPoints
Section titled “cluster.bootstrap.requiredContactPoints”
readonlyrequiredContactPoints:"actor-ts.cluster.bootstrap.required-contact-points"='actor-ts.cluster.bootstrap.required-contact-points'
cluster.bootstrap.selfElectionGrace
Section titled “cluster.bootstrap.selfElectionGrace”
readonlyselfElectionGrace:"actor-ts.cluster.bootstrap.self-election-grace"='actor-ts.cluster.bootstrap.self-election-grace'
cluster.bootstrap.stableMargin
Section titled “cluster.bootstrap.stableMargin”
readonlystableMargin:"actor-ts.cluster.bootstrap.stable-margin"='actor-ts.cluster.bootstrap.stable-margin'
cluster.client
Section titled “cluster.client”
readonlyclient: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.
cluster.client.askTimeout
Section titled “cluster.client.askTimeout”
readonlyaskTimeout:"actor-ts.cluster.client.ask-timeout"='actor-ts.cluster.client.ask-timeout'
cluster.client.connectTimeout
Section titled “cluster.client.connectTimeout”
readonlyconnectTimeout:"actor-ts.cluster.client.connect-timeout"='actor-ts.cluster.client.connect-timeout'
cluster.client.contactPoints
Section titled “cluster.client.contactPoints”
readonlycontactPoints:"actor-ts.cluster.client.contact-points"='actor-ts.cluster.client.contact-points'
cluster.client.receptionist
Section titled “cluster.client.receptionist”
readonlyreceptionist:object
cluster.client.receptionist.askTimeout
Section titled “cluster.client.receptionist.askTimeout”
readonlyaskTimeout:"actor-ts.cluster.client.receptionist.ask-timeout"='actor-ts.cluster.client.receptionist.ask-timeout'
cluster.client.systemName
Section titled “cluster.client.systemName”
readonlysystemName:"actor-ts.cluster.client.system-name"='actor-ts.cluster.client.system-name'
cluster.configurationCompatibilityCheck
Section titled “cluster.configurationCompatibilityCheck”
readonlyconfigurationCompatibilityCheck: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”
readonlycheckedPaths:"actor-ts.cluster.configuration-compatibility-check.checked-paths"='actor-ts.cluster.configuration-compatibility-check.checked-paths'
cluster.configurationCompatibilityCheck.enforce
Section titled “cluster.configurationCompatibilityCheck.enforce”
readonlyenforce:"actor-ts.cluster.configuration-compatibility-check.enforce"='actor-ts.cluster.configuration-compatibility-check.enforce'
cluster.downSmallerIsland
Section titled “cluster.downSmallerIsland”
readonlydownSmallerIsland:"actor-ts.cluster.down-smaller-island"='actor-ts.cluster.down-smaller-island'
ClusterOptionsType.downSmallerIsland (#1176).
cluster.failureDetector
Section titled “cluster.failureDetector”
readonlyfailureDetector: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.
cluster.failureDetector.autoDown
Section titled “cluster.failureDetector.autoDown”
readonlyautoDown:"actor-ts.cluster.failure-detector.auto-down"='actor-ts.cluster.failure-detector.auto-down'
cluster.failureDetector.downAfter
Section titled “cluster.failureDetector.downAfter”
readonlydownAfter:"actor-ts.cluster.failure-detector.down-after"='actor-ts.cluster.failure-detector.down-after'
cluster.failureDetector.heartbeatInterval
Section titled “cluster.failureDetector.heartbeatInterval”
readonlyheartbeatInterval:"actor-ts.cluster.failure-detector.heartbeat-interval"='actor-ts.cluster.failure-detector.heartbeat-interval'
cluster.failureDetector.implementation
Section titled “cluster.failureDetector.implementation”
readonlyimplementation:"actor-ts.cluster.failure-detector.implementation"='actor-ts.cluster.failure-detector.implementation'
cluster.failureDetector.phi
Section titled “cluster.failureDetector.phi”
readonlyphi:object
cluster.failureDetector.phi.acceptableHeartbeatPause
Section titled “cluster.failureDetector.phi.acceptableHeartbeatPause”
readonlyacceptableHeartbeatPause:"actor-ts.cluster.failure-detector.phi.acceptable-heartbeat-pause"='actor-ts.cluster.failure-detector.phi.acceptable-heartbeat-pause'
cluster.failureDetector.phi.downThreshold
Section titled “cluster.failureDetector.phi.downThreshold”
readonlydownThreshold:"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”
readonlyexpectedResponseAfter:"actor-ts.cluster.failure-detector.phi.expected-response-after"='actor-ts.cluster.failure-detector.phi.expected-response-after'
cluster.failureDetector.phi.maxSampleSize
Section titled “cluster.failureDetector.phi.maxSampleSize”
readonlymaxSampleSize:"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”
readonlyminStdDeviation:"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”
readonlyunreachableThreshold:"actor-ts.cluster.failure-detector.phi.unreachable-threshold"='actor-ts.cluster.failure-detector.phi.unreachable-threshold'
cluster.failureDetector.unreachableAfter
Section titled “cluster.failureDetector.unreachableAfter”
readonlyunreachableAfter:"actor-ts.cluster.failure-detector.unreachable-after"='actor-ts.cluster.failure-detector.unreachable-after'
cluster.gossipInterval
Section titled “cluster.gossipInterval”
readonlygossipInterval:"actor-ts.cluster.gossip-interval"='actor-ts.cluster.gossip-interval'
cluster.maxMembers
Section titled “cluster.maxMembers”
readonlymaxMembers:"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.
cluster.maxTombstones
Section titled “cluster.maxTombstones”
readonlymaxTombstones:"actor-ts.cluster.max-tombstones"='actor-ts.cluster.max-tombstones'
cluster.minimumMembersBeforeUp
Section titled “cluster.minimumMembersBeforeUp”
readonlyminimumMembersBeforeUp:"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.
cluster.publishStatsInterval
Section titled “cluster.publishStatsInterval”
readonlypublishStatsInterval:"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.
cluster.pubSub
Section titled “cluster.pubSub”
readonlypubSub: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).
cluster.pubSub.gossipInterval
Section titled “cluster.pubSub.gossipInterval”
readonlygossipInterval:"actor-ts.cluster.pub-sub.gossip-interval"='actor-ts.cluster.pub-sub.gossip-interval'
cluster.pubSub.maxRemoteNodesPerTopic
Section titled “cluster.pubSub.maxRemoteNodesPerTopic”
readonlymaxRemoteNodesPerTopic:"actor-ts.cluster.pub-sub.max-remote-nodes-per-topic"='actor-ts.cluster.pub-sub.max-remote-nodes-per-topic'
cluster.pubSub.maxSubscribersPerTopic
Section titled “cluster.pubSub.maxSubscribersPerTopic”
readonlymaxSubscribersPerTopic:"actor-ts.cluster.pub-sub.max-subscribers-per-topic"='actor-ts.cluster.pub-sub.max-subscribers-per-topic'
cluster.pubSub.maxTopics
Section titled “cluster.pubSub.maxTopics”
readonlymaxTopics:"actor-ts.cluster.pub-sub.max-topics"='actor-ts.cluster.pub-sub.max-topics'
cluster.pubSub.sendToDeadLettersWhenNoSubscribers
Section titled “cluster.pubSub.sendToDeadLettersWhenNoSubscribers”
readonlysendToDeadLettersWhenNoSubscribers:"actor-ts.cluster.pub-sub.send-to-dead-letters-when-no-subscribers"='actor-ts.cluster.pub-sub.send-to-dead-letters-when-no-subscribers'
cluster.receptionist
Section titled “cluster.receptionist”
readonlyreceptionist:object
Receptionist tuning — actor-ts.cluster.receptionist.*. Read once per
ReceptionistExtension.start, which layers them under the explicit
options (#137, #857).
cluster.receptionist.gossipInterval
Section titled “cluster.receptionist.gossipInterval”
readonlygossipInterval:"actor-ts.cluster.receptionist.gossip-interval"='actor-ts.cluster.receptionist.gossip-interval'
cluster.receptionist.maxSubscribersPerKey
Section titled “cluster.receptionist.maxSubscribersPerKey”
readonlymaxSubscribersPerKey:"actor-ts.cluster.receptionist.max-subscribers-per-key"='actor-ts.cluster.receptionist.max-subscribers-per-key'
cluster.receptionist.maxSubscriptionsTotal
Section titled “cluster.receptionist.maxSubscriptionsTotal”
readonlymaxSubscriptionsTotal:"actor-ts.cluster.receptionist.max-subscriptions-total"='actor-ts.cluster.receptionist.max-subscriptions-total'
cluster.role
Section titled “cluster.role”
readonlyrole:"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.
cluster.roles
Section titled “cluster.roles”
readonlyroles:"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.
cluster.runCoordinatedShutdownWhenDown
Section titled “cluster.runCoordinatedShutdownWhenDown”
readonlyrunCoordinatedShutdownWhenDown:"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.
cluster.seedNodes
Section titled “cluster.seedNodes”
readonlyseedNodes:"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.
cluster.seedRetryInterval
Section titled “cluster.seedRetryInterval”
readonlyseedRetryInterval:"actor-ts.cluster.seed-retry-interval"='actor-ts.cluster.seed-retry-interval'
cluster.shutdownAfterUnsuccessfulJoin
Section titled “cluster.shutdownAfterUnsuccessfulJoin”
readonlyshutdownAfterUnsuccessfulJoin:"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.
cluster.singleton
Section titled “cluster.singleton”
readonlysingleton: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.
cluster.singleton.acquireRetryInterval
Section titled “cluster.singleton.acquireRetryInterval”
readonlyacquireRetryInterval:"actor-ts.cluster.singleton.acquire-retry-interval"='actor-ts.cluster.singleton.acquire-retry-interval'
cluster.singleton.bufferSize
Section titled “cluster.singleton.bufferSize”
readonlybufferSize:"actor-ts.cluster.singleton.buffer-size"='actor-ts.cluster.singleton.buffer-size'
cluster.singleton.handOverTimeout
Section titled “cluster.singleton.handOverTimeout”
readonlyhandOverTimeout:"actor-ts.cluster.singleton.hand-over-timeout"='actor-ts.cluster.singleton.hand-over-timeout'
cluster.singleton.maxHandOverStateBytes
Section titled “cluster.singleton.maxHandOverStateBytes”
readonlymaxHandOverStateBytes:"actor-ts.cluster.singleton.max-hand-over-state-bytes"='actor-ts.cluster.singleton.max-hand-over-state-bytes'
cluster.singleton.restartOnTermination
Section titled “cluster.singleton.restartOnTermination”
readonlyrestartOnTermination:"actor-ts.cluster.singleton.restart-on-termination"='actor-ts.cluster.singleton.restart-on-termination'
cluster.singleton.role
Section titled “cluster.singleton.role”
readonlyrole:"actor-ts.cluster.singleton.role"='actor-ts.cluster.singleton.role'
cluster.singleton.useLease
Section titled “cluster.singleton.useLease”
readonlyuseLease:"actor-ts.cluster.singleton.use-lease"='actor-ts.cluster.singleton.use-lease'
cluster.splitBrainResolver
Section titled “cluster.splitBrainResolver”
readonlysplitBrainResolver: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.
cluster.splitBrainResolver.activeStrategy
Section titled “cluster.splitBrainResolver.activeStrategy”
readonlyactiveStrategy:"actor-ts.cluster.split-brain-resolver.active-strategy"='actor-ts.cluster.split-brain-resolver.active-strategy'
cluster.splitBrainResolver.downAllWhenUnstable
Section titled “cluster.splitBrainResolver.downAllWhenUnstable”
readonlydownAllWhenUnstable:"actor-ts.cluster.split-brain-resolver.down-all-when-unstable"='actor-ts.cluster.split-brain-resolver.down-all-when-unstable'
cluster.splitBrainResolver.keepMajority
Section titled “cluster.splitBrainResolver.keepMajority”
readonlykeepMajority:object
cluster.splitBrainResolver.keepMajority.role
Section titled “cluster.splitBrainResolver.keepMajority.role”
readonlyrole:"actor-ts.cluster.split-brain-resolver.keep-majority.role"='actor-ts.cluster.split-brain-resolver.keep-majority.role'
cluster.splitBrainResolver.keepOldest
Section titled “cluster.splitBrainResolver.keepOldest”
readonlykeepOldest:object
cluster.splitBrainResolver.keepOldest.downIfAlone
Section titled “cluster.splitBrainResolver.keepOldest.downIfAlone”
readonlydownIfAlone:"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”
readonlyrole:"actor-ts.cluster.split-brain-resolver.keep-oldest.role"='actor-ts.cluster.split-brain-resolver.keep-oldest.role'
cluster.splitBrainResolver.keepReferee
Section titled “cluster.splitBrainResolver.keepReferee”
readonlykeepReferee:object
cluster.splitBrainResolver.keepReferee.downAllIfBelowQuorum
Section titled “cluster.splitBrainResolver.keepReferee.downAllIfBelowQuorum”
readonlydownAllIfBelowQuorum:"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”
readonlyrefereeAddress:"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.
cluster.splitBrainResolver.stableAfter
Section titled “cluster.splitBrainResolver.stableAfter”
readonlystableAfter:"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”.
cluster.splitBrainResolver.staticQuorum
Section titled “cluster.splitBrainResolver.staticQuorum”
readonlystaticQuorum:object
cluster.splitBrainResolver.staticQuorum.quorumSize
Section titled “cluster.splitBrainResolver.staticQuorum.quorumSize”
readonlyquorumSize:"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”
readonlyrole:"actor-ts.cluster.split-brain-resolver.static-quorum.role"='actor-ts.cluster.split-brain-resolver.static-quorum.role'
cluster.tombstone
Section titled “cluster.tombstone”
readonlytombstone: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.
cluster.tombstone.minRetention
Section titled “cluster.tombstone.minRetention”
readonlyminRetention:"actor-ts.cluster.tombstone.min-retention"='actor-ts.cluster.tombstone.min-retention'
cluster.tombstone.pruneInterval
Section titled “cluster.tombstone.pruneInterval”
readonlypruneInterval:"actor-ts.cluster.tombstone.prune-interval"='actor-ts.cluster.tombstone.prune-interval'
cluster.tombstone.timeToLive
Section titled “cluster.tombstone.timeToLive”
readonlytimeToLive:"actor-ts.cluster.tombstone.time-to-live"='actor-ts.cluster.tombstone.time-to-live'
cluster.weaklyUpAfter
Section titled “cluster.weaklyUpAfter”
readonlyweaklyUpAfter:"actor-ts.cluster.weakly-up-after"='actor-ts.cluster.weakly-up-after'
Auto-promotion joining → weakly-up; 0 keeps it opt-in (#841).
coordinatedShutdown
Section titled “coordinatedShutdown”
readonlycoordinatedShutdown: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).
coordinatedShutdown.autoRegisterTasks
Section titled “coordinatedShutdown.autoRegisterTasks”
readonlyautoRegisterTasks:"actor-ts.coordinated-shutdown.auto-register-tasks"='actor-ts.coordinated-shutdown.auto-register-tasks'
coordinatedShutdown.defaultPhaseTimeout
Section titled “coordinatedShutdown.defaultPhaseTimeout”
readonlydefaultPhaseTimeout:"actor-ts.coordinated-shutdown.default-phase-timeout"='actor-ts.coordinated-shutdown.default-phase-timeout'
coordinatedShutdown.exitCode
Section titled “coordinatedShutdown.exitCode”
readonlyexitCode:"actor-ts.coordinated-shutdown.exit-code"='actor-ts.coordinated-shutdown.exit-code'
coordinatedShutdown.exitProcess
Section titled “coordinatedShutdown.exitProcess”
readonlyexitProcess:"actor-ts.coordinated-shutdown.exit-process"='actor-ts.coordinated-shutdown.exit-process'
coordinatedShutdown.phases
Section titled “coordinatedShutdown.phases”
readonlyphases:"actor-ts.coordinated-shutdown.phases"='actor-ts.coordinated-shutdown.phases'
coordinatedShutdown.runByActorSystemTerminate
Section titled “coordinatedShutdown.runByActorSystemTerminate”
readonlyrunByActorSystemTerminate:"actor-ts.coordinated-shutdown.run-by-actor-system-terminate"='actor-ts.coordinated-shutdown.run-by-actor-system-terminate'
coordinatedShutdown.runByProcessSignals
Section titled “coordinatedShutdown.runByProcessSignals”
readonlyrunByProcessSignals:"actor-ts.coordinated-shutdown.run-by-process-signals"='actor-ts.coordinated-shutdown.run-by-process-signals'
coordinatedShutdown.terminateActorSystem
Section titled “coordinatedShutdown.terminateActorSystem”
readonlyterminateActorSystem:"actor-ts.coordinated-shutdown.terminate-actor-system"='actor-ts.coordinated-shutdown.terminate-actor-system'
coordinatedStartup
Section titled “coordinatedStartup”
readonlycoordinatedStartup: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.
coordinatedStartup.defaultPhaseTimeout
Section titled “coordinatedStartup.defaultPhaseTimeout”
readonlydefaultPhaseTimeout:"actor-ts.coordinated-startup.default-phase-timeout"='actor-ts.coordinated-startup.default-phase-timeout'
coordinatedStartup.phases
Section titled “coordinatedStartup.phases”
readonlyphases:"actor-ts.coordinated-startup.phases"='actor-ts.coordinated-startup.phases'
coordination
Section titled “coordination”
readonlycoordination: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.
coordination.lease
Section titled “coordination.lease”
readonlylease:object
coordination.lease.backend
Section titled “coordination.lease.backend”
readonlybackend:"actor-ts.coordination.lease.backend"='actor-ts.coordination.lease.backend'
coordination.lease.kubernetes
Section titled “coordination.lease.kubernetes”
readonlykubernetes:object
coordination.lease.kubernetes.caPath
Section titled “coordination.lease.kubernetes.caPath”
readonlycaPath:"actor-ts.coordination.lease.kubernetes.ca-path"='actor-ts.coordination.lease.kubernetes.ca-path'
coordination.lease.kubernetes.leaseNameMaxLength
Section titled “coordination.lease.kubernetes.leaseNameMaxLength”
readonlyleaseNameMaxLength:"actor-ts.coordination.lease.kubernetes.lease-name-max-length"='actor-ts.coordination.lease.kubernetes.lease-name-max-length'
coordination.lease.kubernetes.namespace
Section titled “coordination.lease.kubernetes.namespace”
readonlynamespace:"actor-ts.coordination.lease.kubernetes.namespace"='actor-ts.coordination.lease.kubernetes.namespace'
coordination.lease.kubernetes.namespacePath
Section titled “coordination.lease.kubernetes.namespacePath”
readonlynamespacePath:"actor-ts.coordination.lease.kubernetes.namespace-path"='actor-ts.coordination.lease.kubernetes.namespace-path'
coordination.lease.kubernetes.operationTimeout
Section titled “coordination.lease.kubernetes.operationTimeout”
readonlyoperationTimeout:"actor-ts.coordination.lease.kubernetes.operation-timeout"='actor-ts.coordination.lease.kubernetes.operation-timeout'
coordination.lease.kubernetes.tokenPath
Section titled “coordination.lease.kubernetes.tokenPath”
readonlytokenPath:"actor-ts.coordination.lease.kubernetes.token-path"='actor-ts.coordination.lease.kubernetes.token-path'
coordination.lease.kubernetes.tokenReloadInterval
Section titled “coordination.lease.kubernetes.tokenReloadInterval”
readonlytokenReloadInterval:"actor-ts.coordination.lease.kubernetes.token-reload-interval"='actor-ts.coordination.lease.kubernetes.token-reload-interval'
coordination.lease.renewalInterval
Section titled “coordination.lease.renewalInterval”
readonlyrenewalInterval:"actor-ts.coordination.lease.renewal-interval"='actor-ts.coordination.lease.renewal-interval'
coordination.lease.ttl
Section titled “coordination.lease.ttl”
readonlyttl:"actor-ts.coordination.lease.ttl"='actor-ts.coordination.lease.ttl'
deadLetters
Section titled “deadLetters”
readonlydeadLetters: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— besideactor-ts.debug.*. That sketch is superseded: #1000 shipped those three underdiagnosticsbelow, becauseReference.tshas 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.
deadLetters.maxEntries
Section titled “deadLetters.maxEntries”
readonlymaxEntries:"actor-ts.dead-letters.max-entries"='actor-ts.dead-letters.max-entries'
deadLetters.maxReplays
Section titled “deadLetters.maxReplays”
readonlymaxReplays:"actor-ts.dead-letters.max-replays"='actor-ts.dead-letters.max-replays'
deadLetters.persistenceId
Section titled “deadLetters.persistenceId”
readonlypersistenceId:"actor-ts.dead-letters.persistence-id"='actor-ts.dead-letters.persistence-id'
deadLetters.retention
Section titled “deadLetters.retention”
readonlyretention:"actor-ts.dead-letters.retention"='actor-ts.dead-letters.retention'
deadLetters.store
Section titled “deadLetters.store”
readonlystore:"actor-ts.dead-letters.store"='actor-ts.dead-letters.store'
deployment
Section titled “deployment”
readonlydeployment: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.
deployment.entry
Section titled “deployment.entry”
readonlyentry:object
deployment.entry.mailboxCapacity
Section titled “deployment.entry.mailboxCapacity”
readonlymailboxCapacity:"mailbox-capacity"='mailbox-capacity'
deployment.entry.mailboxOverflow
Section titled “deployment.entry.mailboxOverflow”
readonlymailboxOverflow:"mailbox-overflow"='mailbox-overflow'
deployment.entry.throughput
Section titled “deployment.entry.throughput”
readonlythroughput:"throughput"='throughput'
deployment.root
Section titled “deployment.root”
readonlyroot:"actor-ts.deployment"='actor-ts.deployment'
devtools
Section titled “devtools”
readonlydevtools: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).
devtools.allowedOrigins
Section titled “devtools.allowedOrigins”
readonlyallowedOrigins:"actor-ts.devtools.allowed-origins"='actor-ts.devtools.allowed-origins'
devtools.allowRemote
Section titled “devtools.allowRemote”
readonlyallowRemote:"actor-ts.devtools.allow-remote"='actor-ts.devtools.allow-remote'
devtools.capturePayloads
Section titled “devtools.capturePayloads”
readonlycapturePayloads:"actor-ts.devtools.capture-payloads"='actor-ts.devtools.capture-payloads'
devtools.eventBufferCapacity
Section titled “devtools.eventBufferCapacity”
readonlyeventBufferCapacity:"actor-ts.devtools.event-buffer-capacity"='actor-ts.devtools.event-buffer-capacity'
devtools.eventFlushInterval
Section titled “devtools.eventFlushInterval”
readonlyeventFlushInterval:"actor-ts.devtools.event-flush-interval"='actor-ts.devtools.event-flush-interval'
devtools.host
Section titled “devtools.host”
readonlyhost:"actor-ts.devtools.host"='actor-ts.devtools.host'
devtools.mailboxSampleInterval
Section titled “devtools.mailboxSampleInterval”
readonlymailboxSampleInterval:"actor-ts.devtools.mailbox-sample-interval"='actor-ts.devtools.mailbox-sample-interval'
devtools.mailboxSampleLimit
Section titled “devtools.mailboxSampleLimit”
readonlymailboxSampleLimit:"actor-ts.devtools.mailbox-sample-limit"='actor-ts.devtools.mailbox-sample-limit'
devtools.panels
Section titled “devtools.panels”
readonlypanels:object
Per-panel switches; a panel is disabled only by an explicit false.
devtools.panels.actors
Section titled “devtools.panels.actors”
readonlyactors:"actor-ts.devtools.panels.actors"='actor-ts.devtools.panels.actors'
devtools.panels.cluster
Section titled “devtools.panels.cluster”
readonlycluster:"actor-ts.devtools.panels.cluster"='actor-ts.devtools.panels.cluster'
devtools.panels.config
Section titled “devtools.panels.config”
readonlyconfig:"actor-ts.devtools.panels.config"='actor-ts.devtools.panels.config'
devtools.panels.deadLetters
Section titled “devtools.panels.deadLetters”
readonlydeadLetters:"actor-ts.devtools.panels.dead-letters"='actor-ts.devtools.panels.dead-letters'
devtools.panels.eventStream
Section titled “devtools.panels.eventStream”
readonlyeventStream:"actor-ts.devtools.panels.event-stream"='actor-ts.devtools.panels.event-stream'
devtools.panels.explain
Section titled “devtools.panels.explain”
readonlyexplain:"actor-ts.devtools.panels.explain"='actor-ts.devtools.panels.explain'
devtools.panels.profiler
Section titled “devtools.panels.profiler”
readonlyprofiler:"actor-ts.devtools.panels.profiler"='actor-ts.devtools.panels.profiler'
devtools.panels.send
Section titled “devtools.panels.send”
readonlysend:"actor-ts.devtools.panels.send"='actor-ts.devtools.panels.send'
devtools.panels.timeTravel
Section titled “devtools.panels.timeTravel”
readonlytimeTravel:"actor-ts.devtools.panels.time-travel"='actor-ts.devtools.panels.time-travel'
devtools.panels.tracing
Section titled “devtools.panels.tracing”
readonlytracing:"actor-ts.devtools.panels.tracing"='actor-ts.devtools.panels.tracing'
devtools.port
Section titled “devtools.port”
readonlyport:"actor-ts.devtools.port"='actor-ts.devtools.port'
devtools.replayAutoCapture
Section titled “devtools.replayAutoCapture”
readonlyreplayAutoCapture:"actor-ts.devtools.replay-auto-capture"='actor-ts.devtools.replay-auto-capture'
devtools.serveUi
Section titled “devtools.serveUi”
readonlyserveUi:"actor-ts.devtools.serve-ui"='actor-ts.devtools.serve-ui'
devtools.spanBufferCapacity
Section titled “devtools.spanBufferCapacity”
readonlyspanBufferCapacity:"actor-ts.devtools.span-buffer-capacity"='actor-ts.devtools.span-buffer-capacity'
devtools.spanFlushInterval
Section titled “devtools.spanFlushInterval”
readonlyspanFlushInterval:"actor-ts.devtools.span-flush-interval"='actor-ts.devtools.span-flush-interval'
devtools.statsInterval
Section titled “devtools.statsInterval”
readonlystatsInterval:"actor-ts.devtools.stats-interval"='actor-ts.devtools.stats-interval'
diagnostics
Section titled “diagnostics”
readonlydiagnostics: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.
diagnostics.debugEventStream
Section titled “diagnostics.debugEventStream”
readonlydebugEventStream:"actor-ts.diagnostics.debug.event-stream"='actor-ts.diagnostics.debug.event-stream'
diagnostics.debugLifecycle
Section titled “diagnostics.debugLifecycle”
readonlydebugLifecycle:"actor-ts.diagnostics.debug.lifecycle"='actor-ts.diagnostics.debug.lifecycle'
diagnostics.debugUnhandled
Section titled “diagnostics.debugUnhandled”
readonlydebugUnhandled:"actor-ts.diagnostics.debug.unhandled"='actor-ts.diagnostics.debug.unhandled'
diagnostics.logConfigOnStart
Section titled “diagnostics.logConfigOnStart”
readonlylogConfigOnStart:"actor-ts.diagnostics.log-config-on-start"='actor-ts.diagnostics.log-config-on-start'
diagnostics.logDeadLetters
Section titled “diagnostics.logDeadLetters”
readonlylogDeadLetters:"actor-ts.diagnostics.log-dead-letters"='actor-ts.diagnostics.log-dead-letters'
diagnostics.logDeadLettersDuringShutdown
Section titled “diagnostics.logDeadLettersDuringShutdown”
readonlylogDeadLettersDuringShutdown:"actor-ts.diagnostics.log-dead-letters-during-shutdown"='actor-ts.diagnostics.log-dead-letters-during-shutdown'
diagnostics.logDeadLettersSuspendDuration
Section titled “diagnostics.logDeadLettersSuspendDuration”
readonlylogDeadLettersSuspendDuration:"actor-ts.diagnostics.log-dead-letters-suspend-duration"='actor-ts.diagnostics.log-dead-letters-suspend-duration'
discovery
Section titled “discovery”
readonlydiscovery: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.
discovery.config
Section titled “discovery.config”
readonlyconfig:object
discovery.config.seeds
Section titled “discovery.config.seeds”
readonlyseeds:"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.
discovery.dns
Section titled “discovery.dns”
readonlydns:object
discovery.dns.cacheTtl
Section titled “discovery.dns.cacheTtl”
readonlycacheTtl:"actor-ts.discovery.dns.cache-ttl"='actor-ts.discovery.dns.cache-ttl'
discovery.dns.dnsPinnedAddresses
Section titled “discovery.dns.dnsPinnedAddresses”
readonlydnsPinnedAddresses:"actor-ts.discovery.dns.pinned-addresses"='actor-ts.discovery.dns.pinned-addresses'
Comment-only in reference.conf — unset means no pinning.
discovery.dns.useSrv
Section titled “discovery.dns.useSrv”
readonlyuseSrv:"actor-ts.discovery.dns.use-srv"='actor-ts.discovery.dns.use-srv'
discovery.kubernetes
Section titled “discovery.kubernetes”
readonlykubernetes:object
discovery.kubernetes.kubernetesPinnedAddresses
Section titled “discovery.kubernetes.kubernetesPinnedAddresses”
readonlykubernetesPinnedAddresses:"actor-ts.discovery.kubernetes.pinned-addresses"='actor-ts.discovery.kubernetes.pinned-addresses'
Comment-only in reference.conf — unset means no pinning.
discovery.kubernetes.namespace
Section titled “discovery.kubernetes.namespace”
readonlynamespace:"actor-ts.discovery.kubernetes.namespace"='actor-ts.discovery.kubernetes.namespace'
Comment-only in reference.conf — unset falls through to CLUSTER_NAMESPACE.
discovery.kubernetes.requestTimeout
Section titled “discovery.kubernetes.requestTimeout”
readonlyrequestTimeout:"actor-ts.discovery.kubernetes.request-timeout"='actor-ts.discovery.kubernetes.request-timeout'
dispatcher
Section titled “dispatcher”
readonlydispatcher:object
Dispatcher root — actor-ts.dispatcher.*.
dispatcher.default
Section titled “dispatcher.default”
readonlydefault:"actor-ts.dispatcher.default"='actor-ts.dispatcher.default'
dispatcher.throughput
Section titled “dispatcher.throughput”
readonlythroughput:"actor-ts.dispatcher.throughput"='actor-ts.dispatcher.throughput'
distributedData
Section titled “distributedData”
readonlydistributedData: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).
distributedData.durableKeys
Section titled “distributedData.durableKeys”
readonlydurableKeys:"actor-ts.distributed-data.durable-keys"='actor-ts.distributed-data.durable-keys'
distributedData.gossipInterval
Section titled “distributedData.gossipInterval”
readonlygossipInterval:"actor-ts.distributed-data.gossip-interval"='actor-ts.distributed-data.gossip-interval'
distributedData.logDataSizeExceeding
Section titled “distributedData.logDataSizeExceeding”
readonlylogDataSizeExceeding:"actor-ts.distributed-data.log-data-size-exceeding"='actor-ts.distributed-data.log-data-size-exceeding'
distributedData.maxGossipBytes
Section titled “distributedData.maxGossipBytes”
readonlymaxGossipBytes:"actor-ts.distributed-data.max-gossip-bytes"='actor-ts.distributed-data.max-gossip-bytes'
distributedData.maxPendingQuorumRequests
Section titled “distributedData.maxPendingQuorumRequests”
readonlymaxPendingQuorumRequests:"actor-ts.distributed-data.max-pending-quorum-requests"='actor-ts.distributed-data.max-pending-quorum-requests'
distributedData.maxQuorumTimeout
Section titled “distributedData.maxQuorumTimeout”
readonlymaxQuorumTimeout:"actor-ts.distributed-data.max-quorum-timeout"='actor-ts.distributed-data.max-quorum-timeout'
distributedData.quorumTimeout
Section titled “distributedData.quorumTimeout”
readonlyquorumTimeout:"actor-ts.distributed-data.quorum-timeout"='actor-ts.distributed-data.quorum-timeout'
readonlyhttp:object
HTTP subsystem config roots — actor-ts.http.*.
http.backend
Section titled “http.backend”
readonlybackend:"actor-ts.http.backend"='actor-ts.http.backend'
Which shipped backend newServerAt(...).bind() uses when none is set in code.
http.client
Section titled “http.client”
readonlyclient:object
Outbound HttpClient defaults — the shared client and newClient(...).
http.client.defaultTimeout
Section titled “http.client.defaultTimeout”
readonlydefaultTimeout:"actor-ts.http.client.default-timeout"='actor-ts.http.client.default-timeout'
http.client.maxRedirects
Section titled “http.client.maxRedirects”
readonlymaxRedirects:"actor-ts.http.client.max-redirects"='actor-ts.http.client.max-redirects'
http.client.maxResponseBytes
Section titled “http.client.maxResponseBytes”
readonlymaxResponseBytes:"actor-ts.http.client.max-response-bytes"='actor-ts.http.client.max-response-bytes'
http.client.redirect
Section titled “http.client.redirect”
readonlyredirect:"actor-ts.http.client.redirect"='actor-ts.http.client.redirect'
http.client.root
Section titled “http.client.root”
readonlyroot:"actor-ts.http.client"='actor-ts.http.client'
http.cors
Section titled “http.cors”
readonlycors: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.
http.cors.allowedHeaders
Section titled “http.cors.allowedHeaders”
readonlyallowedHeaders:"actor-ts.http.cors.allowed-headers"='actor-ts.http.cors.allowed-headers'
http.cors.credentials
Section titled “http.cors.credentials”
readonlycredentials:"actor-ts.http.cors.credentials"='actor-ts.http.cors.credentials'
http.cors.exposedHeaders
Section titled “http.cors.exposedHeaders”
readonlyexposedHeaders:"actor-ts.http.cors.exposed-headers"='actor-ts.http.cors.exposed-headers'
http.cors.maxAge
Section titled “http.cors.maxAge”
readonlymaxAge:"actor-ts.http.cors.max-age"='actor-ts.http.cors.max-age'
http.cors.methods
Section titled “http.cors.methods”
readonlymethods:"actor-ts.http.cors.methods"='actor-ts.http.cors.methods'
http.cors.origins
Section titled “http.cors.origins”
readonlyorigins:"actor-ts.http.cors.origins"='actor-ts.http.cors.origins'
http.cors.root
Section titled “http.cors.root”
readonlyroot:"actor-ts.http.cors"='actor-ts.http.cors'
http.hsts
Section titled “http.hsts”
readonlyhsts: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.
http.hsts.includeSubDomains
Section titled “http.hsts.includeSubDomains”
readonlyincludeSubDomains:"actor-ts.http.hsts.include-sub-domains"='actor-ts.http.hsts.include-sub-domains'
http.hsts.maxAge
Section titled “http.hsts.maxAge”
readonlymaxAge:"actor-ts.http.hsts.max-age"='actor-ts.http.hsts.max-age'
http.hsts.preload
Section titled “http.hsts.preload”
readonlypreload:"actor-ts.http.hsts.preload"='actor-ts.http.hsts.preload'
http.hsts.root
Section titled “http.hsts.root”
readonlyroot:"actor-ts.http.hsts"='actor-ts.http.hsts'
http.requestTimeout
Section titled “http.requestTimeout”
readonlyrequestTimeout: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.
http.requestTimeout.deadline
Section titled “http.requestTimeout.deadline”
readonlydeadline:"actor-ts.http.request-timeout.deadline"='actor-ts.http.request-timeout.deadline'
http.requestTimeout.root
Section titled “http.requestTimeout.root”
readonlyroot:"actor-ts.http.request-timeout"='actor-ts.http.request-timeout'
http.server
Section titled “http.server”
readonlyserver: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).
http.server.headerTimeout
Section titled “http.server.headerTimeout”
readonlyheaderTimeout:"actor-ts.http.server.header-timeout"='actor-ts.http.server.header-timeout'
http.server.http2
Section titled “http.server.http2”
readonlyhttp2:"actor-ts.http.server.http2"='actor-ts.http.server.http2'
http.server.idleTimeout
Section titled “http.server.idleTimeout”
readonlyidleTimeout:"actor-ts.http.server.idle-timeout"='actor-ts.http.server.idle-timeout'
Comment-only in reference.conf — unset keeps the backend’s own.
http.server.maxConnections
Section titled “http.server.maxConnections”
readonlymaxConnections:"actor-ts.http.server.max-connections"='actor-ts.http.server.max-connections'
Comment-only in reference.conf — unset means unlimited.
http.server.maxContentLength
Section titled “http.server.maxContentLength”
readonlymaxContentLength:"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.
http.server.maxHeaderBytes
Section titled “http.server.maxHeaderBytes”
readonlymaxHeaderBytes:"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.
http.server.requestTimeout
Section titled “http.server.requestTimeout”
readonlyrequestTimeout:"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).
http.server.root
Section titled “http.server.root”
readonlyroot:"actor-ts.http.server"='actor-ts.http.server'
http.server.tls
Section titled “http.server.tls”
readonlytls: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).
http.server.tls.caFile
Section titled “http.server.tls.caFile”
readonlycaFile:"actor-ts.http.server.tls.ca-file"='actor-ts.http.server.tls.ca-file'
http.server.tls.certFile
Section titled “http.server.tls.certFile”
readonlycertFile:"actor-ts.http.server.tls.cert-file"='actor-ts.http.server.tls.cert-file'
http.server.tls.keyFile
Section titled “http.server.tls.keyFile”
readonlykeyFile:"actor-ts.http.server.tls.key-file"='actor-ts.http.server.tls.key-file'
http.server.tls.rejectUnauthorized
Section titled “http.server.tls.rejectUnauthorized”
readonlyrejectUnauthorized:"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.
http.server.tls.requestClientCert
Section titled “http.server.tls.requestClientCert”
readonlyrequestClientCert:"actor-ts.http.server.tls.request-client-cert"='actor-ts.http.server.tls.request-client-cert'
http.shutdownGracePeriod
Section titled “http.shutdownGracePeriod”
readonlyshutdownGracePeriod:"actor-ts.http.shutdown-grace-period"='actor-ts.http.shutdown-grace-period'
How long unbind() lets in-flight requests drain before forcing.
http.websocket
Section titled “http.websocket”
readonlywebsocket: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.
http.websocket.acceptTimeout
Section titled “http.websocket.acceptTimeout”
readonlyacceptTimeout:"actor-ts.http.websocket.accept-timeout"='actor-ts.http.websocket.accept-timeout'
http.websocket.connectionMailboxCapacity
Section titled “http.websocket.connectionMailboxCapacity”
readonlyconnectionMailboxCapacity:"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).
http.websocket.connectionMailboxOverflow
Section titled “http.websocket.connectionMailboxOverflow”
readonlyconnectionMailboxOverflow:"actor-ts.http.websocket.connection-mailbox-overflow"='actor-ts.http.websocket.connection-mailbox-overflow'
Comment-only in reference.conf; only meaningful beside a capacity.
http.websocket.maxBufferedBytes
Section titled “http.websocket.maxBufferedBytes”
readonlymaxBufferedBytes:"actor-ts.http.websocket.max-buffered-bytes"='actor-ts.http.websocket.max-buffered-bytes'
http.websocket.maxConnections
Section titled “http.websocket.maxConnections”
readonlymaxConnections:"actor-ts.http.websocket.max-connections"='actor-ts.http.websocket.max-connections'
Comment-only in reference.conf — unset means unlimited.
http.websocket.maxFrameBytes
Section titled “http.websocket.maxFrameBytes”
readonlymaxFrameBytes:"actor-ts.http.websocket.max-frame-bytes"='actor-ts.http.websocket.max-frame-bytes'
http.websocket.maxPreAttachBytes
Section titled “http.websocket.maxPreAttachBytes”
readonlymaxPreAttachBytes:"actor-ts.http.websocket.max-pre-attach-bytes"='actor-ts.http.websocket.max-pre-attach-bytes'
http.websocket.maxPreAttachFrames
Section titled “http.websocket.maxPreAttachFrames”
readonlymaxPreAttachFrames:"actor-ts.http.websocket.max-pre-attach-frames"='actor-ts.http.websocket.max-pre-attach-frames'
http.websocket.onBackpressure
Section titled “http.websocket.onBackpressure”
readonlyonBackpressure:"actor-ts.http.websocket.on-backpressure"='actor-ts.http.websocket.on-backpressure'
http.websocket.onInvalidMessage
Section titled “http.websocket.onInvalidMessage”
readonlyonInvalidMessage:"actor-ts.http.websocket.on-invalid-message"='actor-ts.http.websocket.on-invalid-message'
http.websocket.onOversizeFrame
Section titled “http.websocket.onOversizeFrame”
readonlyonOversizeFrame:"actor-ts.http.websocket.on-oversize-frame"='actor-ts.http.websocket.on-oversize-frame'
http.websocket.root
Section titled “http.websocket.root”
readonlyroot:"actor-ts.http.websocket"='actor-ts.http.websocket'
readonlyio: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.
io.broker
Section titled “io.broker”
readonlybroker:object
io.broker.amqp
Section titled “io.broker.amqp”
readonlyamqp:object
AmqpActor.
io.broker.amqp.autoAcknowledge
Section titled “io.broker.amqp.autoAcknowledge”
readonlyautoAcknowledge:"actor-ts.io.broker.amqp.auto-acknowledge"='actor-ts.io.broker.amqp.auto-acknowledge'
io.broker.amqp.prefetch
Section titled “io.broker.amqp.prefetch”
readonlyprefetch:"actor-ts.io.broker.amqp.prefetch"='actor-ts.io.broker.amqp.prefetch'
io.broker.amqp.root
Section titled “io.broker.amqp.root”
readonlyroot:"actor-ts.io.broker.amqp"='actor-ts.io.broker.amqp'
io.broker.amqp.url
Section titled “io.broker.amqp.url”
readonlyurl:"actor-ts.io.broker.amqp.url"='actor-ts.io.broker.amqp.url'
io.broker.emailBridge
Section titled “io.broker.emailBridge”
readonlyemailBridge: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.
io.broker.emailBridge.imap
Section titled “io.broker.emailBridge.imap”
readonlyimap:object
io.broker.emailBridge.imap.acknowledgmentTimeout
Section titled “io.broker.emailBridge.imap.acknowledgmentTimeout”
readonlyacknowledgmentTimeout:"actor-ts.io.broker.email-bridge.imap.acknowledgment-timeout"='actor-ts.io.broker.email-bridge.imap.acknowledgment-timeout'
io.broker.emailBridge.imap.disableIdle
Section titled “io.broker.emailBridge.imap.disableIdle”
readonlydisableIdle:"actor-ts.io.broker.email-bridge.imap.disable-idle"='actor-ts.io.broker.email-bridge.imap.disable-idle'
io.broker.emailBridge.imap.host
Section titled “io.broker.emailBridge.imap.host”
readonlyhost:"actor-ts.io.broker.email-bridge.imap.host"='actor-ts.io.broker.email-bridge.imap.host'
io.broker.emailBridge.imap.mailbox
Section titled “io.broker.emailBridge.imap.mailbox”
readonlymailbox:"actor-ts.io.broker.email-bridge.imap.mailbox"='actor-ts.io.broker.email-bridge.imap.mailbox'
io.broker.emailBridge.imap.maxIdleTime
Section titled “io.broker.emailBridge.imap.maxIdleTime”
readonlymaxIdleTime:"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”
readonlymaxMessageBytes:"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.
io.broker.emailBridge.imap.moveToMailbox
Section titled “io.broker.emailBridge.imap.moveToMailbox”
readonlymoveToMailbox:"actor-ts.io.broker.email-bridge.imap.move-to-mailbox"='actor-ts.io.broker.email-bridge.imap.move-to-mailbox'
io.broker.emailBridge.imap.onProcessed
Section titled “io.broker.emailBridge.imap.onProcessed”
readonlyonProcessed:"actor-ts.io.broker.email-bridge.imap.on-processed"='actor-ts.io.broker.email-bridge.imap.on-processed'
io.broker.emailBridge.imap.password
Section titled “io.broker.emailBridge.imap.password”
readonlypassword:"actor-ts.io.broker.email-bridge.imap.password"='actor-ts.io.broker.email-bridge.imap.password'
io.broker.emailBridge.imap.pollInterval
Section titled “io.broker.emailBridge.imap.pollInterval”
readonlypollInterval:"actor-ts.io.broker.email-bridge.imap.poll-interval"='actor-ts.io.broker.email-bridge.imap.poll-interval'
io.broker.emailBridge.imap.port
Section titled “io.broker.emailBridge.imap.port”
readonlyport:"actor-ts.io.broker.email-bridge.imap.port"='actor-ts.io.broker.email-bridge.imap.port'
io.broker.emailBridge.imap.root
Section titled “io.broker.emailBridge.imap.root”
readonlyroot:"actor-ts.io.broker.email-bridge.imap"='actor-ts.io.broker.email-bridge.imap'
io.broker.emailBridge.imap.secure
Section titled “io.broker.emailBridge.imap.secure”
readonlysecure:"actor-ts.io.broker.email-bridge.imap.secure"='actor-ts.io.broker.email-bridge.imap.secure'
io.broker.emailBridge.imap.user
Section titled “io.broker.emailBridge.imap.user”
readonlyuser:"actor-ts.io.broker.email-bridge.imap.user"='actor-ts.io.broker.email-bridge.imap.user'
io.broker.emailBridge.root
Section titled “io.broker.emailBridge.root”
readonlyroot:"actor-ts.io.broker.email-bridge"='actor-ts.io.broker.email-bridge'
io.broker.emailBridge.smtp
Section titled “io.broker.emailBridge.smtp”
readonlysmtp:object
io.broker.emailBridge.smtp.from
Section titled “io.broker.emailBridge.smtp.from”
readonlyfrom:"actor-ts.io.broker.email-bridge.smtp.from"='actor-ts.io.broker.email-bridge.smtp.from'
io.broker.emailBridge.smtp.host
Section titled “io.broker.emailBridge.smtp.host”
readonlyhost:"actor-ts.io.broker.email-bridge.smtp.host"='actor-ts.io.broker.email-bridge.smtp.host'
io.broker.emailBridge.smtp.maxConnections
Section titled “io.broker.emailBridge.smtp.maxConnections”
readonlymaxConnections:"actor-ts.io.broker.email-bridge.smtp.max-connections"='actor-ts.io.broker.email-bridge.smtp.max-connections'
io.broker.emailBridge.smtp.maxMessages
Section titled “io.broker.emailBridge.smtp.maxMessages”
readonlymaxMessages:"actor-ts.io.broker.email-bridge.smtp.max-messages"='actor-ts.io.broker.email-bridge.smtp.max-messages'
io.broker.emailBridge.smtp.password
Section titled “io.broker.emailBridge.smtp.password”
readonlypassword:"actor-ts.io.broker.email-bridge.smtp.password"='actor-ts.io.broker.email-bridge.smtp.password'
io.broker.emailBridge.smtp.port
Section titled “io.broker.emailBridge.smtp.port”
readonlyport:"actor-ts.io.broker.email-bridge.smtp.port"='actor-ts.io.broker.email-bridge.smtp.port'
io.broker.emailBridge.smtp.root
Section titled “io.broker.emailBridge.smtp.root”
readonlyroot:"actor-ts.io.broker.email-bridge.smtp"='actor-ts.io.broker.email-bridge.smtp'
io.broker.emailBridge.smtp.secure
Section titled “io.broker.emailBridge.smtp.secure”
readonlysecure:"actor-ts.io.broker.email-bridge.smtp.secure"='actor-ts.io.broker.email-bridge.smtp.secure'
io.broker.emailBridge.smtp.user
Section titled “io.broker.emailBridge.smtp.user”
readonlyuser:"actor-ts.io.broker.email-bridge.smtp.user"='actor-ts.io.broker.email-bridge.smtp.user'
io.broker.grpc
Section titled “io.broker.grpc”
readonlygrpc:object
io.broker.grpc.client
Section titled “io.broker.grpc.client”
readonlyclient:object
GrpcClientActor. proto-path is one file or a list of them.
io.broker.grpc.client.deadline
Section titled “io.broker.grpc.client.deadline”
readonlydeadline:"actor-ts.io.broker.grpc.client.deadline"='actor-ts.io.broker.grpc.client.deadline'
io.broker.grpc.client.endpoint
Section titled “io.broker.grpc.client.endpoint”
readonlyendpoint:"actor-ts.io.broker.grpc.client.endpoint"='actor-ts.io.broker.grpc.client.endpoint'
io.broker.grpc.client.packageName
Section titled “io.broker.grpc.client.packageName”
readonlypackageName:"actor-ts.io.broker.grpc.client.package-name"='actor-ts.io.broker.grpc.client.package-name'
io.broker.grpc.client.protoPath
Section titled “io.broker.grpc.client.protoPath”
readonlyprotoPath:"actor-ts.io.broker.grpc.client.proto-path"='actor-ts.io.broker.grpc.client.proto-path'
io.broker.grpc.client.root
Section titled “io.broker.grpc.client.root”
readonlyroot:"actor-ts.io.broker.grpc.client"='actor-ts.io.broker.grpc.client'
io.broker.grpc.client.serviceName
Section titled “io.broker.grpc.client.serviceName”
readonlyserviceName:"actor-ts.io.broker.grpc.client.service-name"='actor-ts.io.broker.grpc.client.service-name'
io.broker.grpc.server
Section titled “io.broker.grpc.server”
readonlyserver: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.
io.broker.grpc.server.bind
Section titled “io.broker.grpc.server.bind”
readonlybind:"actor-ts.io.broker.grpc.server.bind"='actor-ts.io.broker.grpc.server.bind'
io.broker.grpc.server.packageName
Section titled “io.broker.grpc.server.packageName”
readonlypackageName:"actor-ts.io.broker.grpc.server.package-name"='actor-ts.io.broker.grpc.server.package-name'
io.broker.grpc.server.protoPath
Section titled “io.broker.grpc.server.protoPath”
readonlyprotoPath:"actor-ts.io.broker.grpc.server.proto-path"='actor-ts.io.broker.grpc.server.proto-path'
io.broker.grpc.server.root
Section titled “io.broker.grpc.server.root”
readonlyroot:"actor-ts.io.broker.grpc.server"='actor-ts.io.broker.grpc.server'
io.broker.grpc.server.serviceName
Section titled “io.broker.grpc.server.serviceName”
readonlyserviceName:"actor-ts.io.broker.grpc.server.service-name"='actor-ts.io.broker.grpc.server.service-name'
io.broker.jetstream
Section titled “io.broker.jetstream”
readonlyjetstream: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.
io.broker.jetstream.acknowledgmentTimeout
Section titled “io.broker.jetstream.acknowledgmentTimeout”
readonlyacknowledgmentTimeout:"actor-ts.io.broker.jetstream.acknowledgment-timeout"='actor-ts.io.broker.jetstream.acknowledgment-timeout'
io.broker.jetstream.consumer
Section titled “io.broker.jetstream.consumer”
readonlyconsumer:object
io.broker.jetstream.consumer.ackPolicy
Section titled “io.broker.jetstream.consumer.ackPolicy”
readonlyackPolicy:"actor-ts.io.broker.jetstream.consumer.ack-policy"='actor-ts.io.broker.jetstream.consumer.ack-policy'
io.broker.jetstream.consumer.ackWait
Section titled “io.broker.jetstream.consumer.ackWait”
readonlyackWait:"actor-ts.io.broker.jetstream.consumer.ack-wait"='actor-ts.io.broker.jetstream.consumer.ack-wait'
io.broker.jetstream.consumer.create
Section titled “io.broker.jetstream.consumer.create”
readonlycreate:"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”
readonlydeliverPolicy:object
io.broker.jetstream.consumer.deliverPolicy.kind
Section titled “io.broker.jetstream.consumer.deliverPolicy.kind”
readonlykind:"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”
readonlyroot:"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”
readonlystartSeq:"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”
readonlystartTime:"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.
io.broker.jetstream.consumer.durable
Section titled “io.broker.jetstream.consumer.durable”
readonlydurable:"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”
readonlyfilterSubject:"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”
readonlymaxAcknowledgmentPending:"actor-ts.io.broker.jetstream.consumer.max-acknowledgment-pending"='actor-ts.io.broker.jetstream.consumer.max-acknowledgment-pending'
io.broker.jetstream.consumer.mode
Section titled “io.broker.jetstream.consumer.mode”
readonlymode:"actor-ts.io.broker.jetstream.consumer.mode"='actor-ts.io.broker.jetstream.consumer.mode'
io.broker.jetstream.consumer.root
Section titled “io.broker.jetstream.consumer.root”
readonlyroot:"actor-ts.io.broker.jetstream.consumer"='actor-ts.io.broker.jetstream.consumer'
io.broker.jetstream.name
Section titled “io.broker.jetstream.name”
readonlyname:"actor-ts.io.broker.jetstream.name"='actor-ts.io.broker.jetstream.name'
io.broker.jetstream.password
Section titled “io.broker.jetstream.password”
readonlypassword:"actor-ts.io.broker.jetstream.password"='actor-ts.io.broker.jetstream.password'
io.broker.jetstream.root
Section titled “io.broker.jetstream.root”
readonlyroot:"actor-ts.io.broker.jetstream"='actor-ts.io.broker.jetstream'
io.broker.jetstream.servers
Section titled “io.broker.jetstream.servers”
readonlyservers:"actor-ts.io.broker.jetstream.servers"='actor-ts.io.broker.jetstream.servers'
io.broker.jetstream.stream
Section titled “io.broker.jetstream.stream”
readonlystream:object
io.broker.jetstream.stream.create
Section titled “io.broker.jetstream.stream.create”
readonlycreate:"actor-ts.io.broker.jetstream.stream.create"='actor-ts.io.broker.jetstream.stream.create'
io.broker.jetstream.stream.maxAge
Section titled “io.broker.jetstream.stream.maxAge”
readonlymaxAge:"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.
io.broker.jetstream.stream.maxBytes
Section titled “io.broker.jetstream.stream.maxBytes”
readonlymaxBytes:"actor-ts.io.broker.jetstream.stream.max-bytes"='actor-ts.io.broker.jetstream.stream.max-bytes'
io.broker.jetstream.stream.maxMessages
Section titled “io.broker.jetstream.stream.maxMessages”
readonlymaxMessages:"actor-ts.io.broker.jetstream.stream.max-messages"='actor-ts.io.broker.jetstream.stream.max-messages'
io.broker.jetstream.stream.name
Section titled “io.broker.jetstream.stream.name”
readonlyname:"actor-ts.io.broker.jetstream.stream.name"='actor-ts.io.broker.jetstream.stream.name'
io.broker.jetstream.stream.retention
Section titled “io.broker.jetstream.stream.retention”
readonlyretention:"actor-ts.io.broker.jetstream.stream.retention"='actor-ts.io.broker.jetstream.stream.retention'
io.broker.jetstream.stream.root
Section titled “io.broker.jetstream.stream.root”
readonlyroot:"actor-ts.io.broker.jetstream.stream"='actor-ts.io.broker.jetstream.stream'
io.broker.jetstream.stream.storage
Section titled “io.broker.jetstream.stream.storage”
readonlystorage:"actor-ts.io.broker.jetstream.stream.storage"='actor-ts.io.broker.jetstream.stream.storage'
io.broker.jetstream.stream.subjects
Section titled “io.broker.jetstream.stream.subjects”
readonlysubjects:"actor-ts.io.broker.jetstream.stream.subjects"='actor-ts.io.broker.jetstream.stream.subjects'
io.broker.jetstream.token
Section titled “io.broker.jetstream.token”
readonlytoken:"actor-ts.io.broker.jetstream.token"='actor-ts.io.broker.jetstream.token'
io.broker.jetstream.user
Section titled “io.broker.jetstream.user”
readonlyuser:"actor-ts.io.broker.jetstream.user"='actor-ts.io.broker.jetstream.user'
io.broker.jetstreamKeyValue
Section titled “io.broker.jetstreamKeyValue”
readonlyjetstreamKeyValue: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.
io.broker.jetstreamKeyValue.bucket
Section titled “io.broker.jetstreamKeyValue.bucket”
readonlybucket:"actor-ts.io.broker.jetstream-key-value.bucket"='actor-ts.io.broker.jetstream-key-value.bucket'
io.broker.jetstreamKeyValue.create
Section titled “io.broker.jetstreamKeyValue.create”
readonlycreate:"actor-ts.io.broker.jetstream-key-value.create"='actor-ts.io.broker.jetstream-key-value.create'
io.broker.jetstreamKeyValue.history
Section titled “io.broker.jetstreamKeyValue.history”
readonlyhistory:"actor-ts.io.broker.jetstream-key-value.history"='actor-ts.io.broker.jetstream-key-value.history'
io.broker.jetstreamKeyValue.maxValueBytes
Section titled “io.broker.jetstreamKeyValue.maxValueBytes”
readonlymaxValueBytes:"actor-ts.io.broker.jetstream-key-value.max-value-bytes"='actor-ts.io.broker.jetstream-key-value.max-value-bytes'
io.broker.jetstreamKeyValue.name
Section titled “io.broker.jetstreamKeyValue.name”
readonlyname:"actor-ts.io.broker.jetstream-key-value.name"='actor-ts.io.broker.jetstream-key-value.name'
io.broker.jetstreamKeyValue.password
Section titled “io.broker.jetstreamKeyValue.password”
readonlypassword:"actor-ts.io.broker.jetstream-key-value.password"='actor-ts.io.broker.jetstream-key-value.password'
io.broker.jetstreamKeyValue.replicas
Section titled “io.broker.jetstreamKeyValue.replicas”
readonlyreplicas:"actor-ts.io.broker.jetstream-key-value.replicas"='actor-ts.io.broker.jetstream-key-value.replicas'
io.broker.jetstreamKeyValue.root
Section titled “io.broker.jetstreamKeyValue.root”
readonlyroot:"actor-ts.io.broker.jetstream-key-value"='actor-ts.io.broker.jetstream-key-value'
io.broker.jetstreamKeyValue.servers
Section titled “io.broker.jetstreamKeyValue.servers”
readonlyservers:"actor-ts.io.broker.jetstream-key-value.servers"='actor-ts.io.broker.jetstream-key-value.servers'
io.broker.jetstreamKeyValue.storage
Section titled “io.broker.jetstreamKeyValue.storage”
readonlystorage:"actor-ts.io.broker.jetstream-key-value.storage"='actor-ts.io.broker.jetstream-key-value.storage'
io.broker.jetstreamKeyValue.timeToLive
Section titled “io.broker.jetstreamKeyValue.timeToLive”
readonlytimeToLive:"actor-ts.io.broker.jetstream-key-value.time-to-live"='actor-ts.io.broker.jetstream-key-value.time-to-live'
io.broker.jetstreamKeyValue.token
Section titled “io.broker.jetstreamKeyValue.token”
readonlytoken:"actor-ts.io.broker.jetstream-key-value.token"='actor-ts.io.broker.jetstream-key-value.token'
io.broker.jetstreamKeyValue.user
Section titled “io.broker.jetstreamKeyValue.user”
readonlyuser:"actor-ts.io.broker.jetstream-key-value.user"='actor-ts.io.broker.jetstream-key-value.user'
io.broker.jetstreamObjectStore
Section titled “io.broker.jetstreamObjectStore”
readonlyjetstreamObjectStore:object
io.broker.jetstreamObjectStore.bucket
Section titled “io.broker.jetstreamObjectStore.bucket”
readonlybucket:"actor-ts.io.broker.jetstream-object-store.bucket"='actor-ts.io.broker.jetstream-object-store.bucket'
io.broker.jetstreamObjectStore.create
Section titled “io.broker.jetstreamObjectStore.create”
readonlycreate:"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”
readonlydescription:"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”
readonlymaxObjectBytes:"actor-ts.io.broker.jetstream-object-store.max-object-bytes"='actor-ts.io.broker.jetstream-object-store.max-object-bytes'
io.broker.jetstreamObjectStore.name
Section titled “io.broker.jetstreamObjectStore.name”
readonlyname:"actor-ts.io.broker.jetstream-object-store.name"='actor-ts.io.broker.jetstream-object-store.name'
io.broker.jetstreamObjectStore.password
Section titled “io.broker.jetstreamObjectStore.password”
readonlypassword:"actor-ts.io.broker.jetstream-object-store.password"='actor-ts.io.broker.jetstream-object-store.password'
io.broker.jetstreamObjectStore.replicas
Section titled “io.broker.jetstreamObjectStore.replicas”
readonlyreplicas:"actor-ts.io.broker.jetstream-object-store.replicas"='actor-ts.io.broker.jetstream-object-store.replicas'
io.broker.jetstreamObjectStore.root
Section titled “io.broker.jetstreamObjectStore.root”
readonlyroot:"actor-ts.io.broker.jetstream-object-store"='actor-ts.io.broker.jetstream-object-store'
io.broker.jetstreamObjectStore.servers
Section titled “io.broker.jetstreamObjectStore.servers”
readonlyservers:"actor-ts.io.broker.jetstream-object-store.servers"='actor-ts.io.broker.jetstream-object-store.servers'
io.broker.jetstreamObjectStore.storage
Section titled “io.broker.jetstreamObjectStore.storage”
readonlystorage:"actor-ts.io.broker.jetstream-object-store.storage"='actor-ts.io.broker.jetstream-object-store.storage'
io.broker.jetstreamObjectStore.token
Section titled “io.broker.jetstreamObjectStore.token”
readonlytoken:"actor-ts.io.broker.jetstream-object-store.token"='actor-ts.io.broker.jetstream-object-store.token'
io.broker.jetstreamObjectStore.user
Section titled “io.broker.jetstreamObjectStore.user”
readonlyuser:"actor-ts.io.broker.jetstream-object-store.user"='actor-ts.io.broker.jetstream-object-store.user'
io.broker.kafka
Section titled “io.broker.kafka”
readonlykafka: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.
io.broker.kafka.brokers
Section titled “io.broker.kafka.brokers”
readonlybrokers:"actor-ts.io.broker.kafka.brokers"='actor-ts.io.broker.kafka.brokers'
io.broker.kafka.clientId
Section titled “io.broker.kafka.clientId”
readonlyclientId:"actor-ts.io.broker.kafka.client-id"='actor-ts.io.broker.kafka.client-id'
io.broker.kafka.consumer
Section titled “io.broker.kafka.consumer”
readonlyconsumer:object
io.broker.kafka.consumer.commitMode
Section titled “io.broker.kafka.consumer.commitMode”
readonlycommitMode:"actor-ts.io.broker.kafka.consumer.commit-mode"='actor-ts.io.broker.kafka.consumer.commit-mode'
io.broker.kafka.consumer.commitTimeout
Section titled “io.broker.kafka.consumer.commitTimeout”
readonlycommitTimeout:"actor-ts.io.broker.kafka.consumer.commit-timeout"='actor-ts.io.broker.kafka.consumer.commit-timeout'
io.broker.kafka.consumer.fromBeginning
Section titled “io.broker.kafka.consumer.fromBeginning”
readonlyfromBeginning:"actor-ts.io.broker.kafka.consumer.from-beginning"='actor-ts.io.broker.kafka.consumer.from-beginning'
io.broker.kafka.consumer.groupId
Section titled “io.broker.kafka.consumer.groupId”
readonlygroupId:"actor-ts.io.broker.kafka.consumer.group-id"='actor-ts.io.broker.kafka.consumer.group-id'
io.broker.kafka.consumer.root
Section titled “io.broker.kafka.consumer.root”
readonlyroot:"actor-ts.io.broker.kafka.consumer"='actor-ts.io.broker.kafka.consumer'
io.broker.kafka.producer
Section titled “io.broker.kafka.producer”
readonlyproducer:object
io.broker.kafka.producer.allowAutoTopicCreation
Section titled “io.broker.kafka.producer.allowAutoTopicCreation”
readonlyallowAutoTopicCreation:"actor-ts.io.broker.kafka.producer.allow-auto-topic-creation"='actor-ts.io.broker.kafka.producer.allow-auto-topic-creation'
io.broker.kafka.producer.idempotent
Section titled “io.broker.kafka.producer.idempotent”
readonlyidempotent:"actor-ts.io.broker.kafka.producer.idempotent"='actor-ts.io.broker.kafka.producer.idempotent'
io.broker.kafka.producer.root
Section titled “io.broker.kafka.producer.root”
readonlyroot:"actor-ts.io.broker.kafka.producer"='actor-ts.io.broker.kafka.producer'
io.broker.kafka.root
Section titled “io.broker.kafka.root”
readonlyroot:"actor-ts.io.broker.kafka"='actor-ts.io.broker.kafka'
io.broker.kafka.sasl
Section titled “io.broker.kafka.sasl”
readonlysasl:object
io.broker.kafka.sasl.mechanism
Section titled “io.broker.kafka.sasl.mechanism”
readonlymechanism:"actor-ts.io.broker.kafka.sasl.mechanism"='actor-ts.io.broker.kafka.sasl.mechanism'
io.broker.kafka.sasl.password
Section titled “io.broker.kafka.sasl.password”
readonlypassword:"actor-ts.io.broker.kafka.sasl.password"='actor-ts.io.broker.kafka.sasl.password'
io.broker.kafka.sasl.root
Section titled “io.broker.kafka.sasl.root”
readonlyroot:"actor-ts.io.broker.kafka.sasl"='actor-ts.io.broker.kafka.sasl'
io.broker.kafka.sasl.username
Section titled “io.broker.kafka.sasl.username”
readonlyusername:"actor-ts.io.broker.kafka.sasl.username"='actor-ts.io.broker.kafka.sasl.username'
io.broker.kafka.ssl
Section titled “io.broker.kafka.ssl”
readonlyssl:"actor-ts.io.broker.kafka.ssl"='actor-ts.io.broker.kafka.ssl'
Boolean only: the certificate-material form of ssl is code-only.
io.broker.kafka.topics
Section titled “io.broker.kafka.topics”
readonlytopics:"actor-ts.io.broker.kafka.topics"='actor-ts.io.broker.kafka.topics'
io.broker.mqtt
Section titled “io.broker.mqtt”
readonlymqtt: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.
io.broker.mqtt.brokerUrl
Section titled “io.broker.mqtt.brokerUrl”
readonlybrokerUrl:"actor-ts.io.broker.mqtt.broker-url"='actor-ts.io.broker.mqtt.broker-url'
io.broker.mqtt.cleanSession
Section titled “io.broker.mqtt.cleanSession”
readonlycleanSession:"actor-ts.io.broker.mqtt.clean-session"='actor-ts.io.broker.mqtt.clean-session'
io.broker.mqtt.clientId
Section titled “io.broker.mqtt.clientId”
readonlyclientId:"actor-ts.io.broker.mqtt.client-id"='actor-ts.io.broker.mqtt.client-id'
io.broker.mqtt.credentials
Section titled “io.broker.mqtt.credentials”
readonlycredentials:object
io.broker.mqtt.credentials.password
Section titled “io.broker.mqtt.credentials.password”
readonlypassword:"actor-ts.io.broker.mqtt.credentials.password"='actor-ts.io.broker.mqtt.credentials.password'
io.broker.mqtt.credentials.root
Section titled “io.broker.mqtt.credentials.root”
readonlyroot:"actor-ts.io.broker.mqtt.credentials"='actor-ts.io.broker.mqtt.credentials'
io.broker.mqtt.credentials.username
Section titled “io.broker.mqtt.credentials.username”
readonlyusername:"actor-ts.io.broker.mqtt.credentials.username"='actor-ts.io.broker.mqtt.credentials.username'
io.broker.mqtt.keepAlive
Section titled “io.broker.mqtt.keepAlive”
readonlykeepAlive:"actor-ts.io.broker.mqtt.keep-alive"='actor-ts.io.broker.mqtt.keep-alive'
io.broker.mqtt.protocolVersion
Section titled “io.broker.mqtt.protocolVersion”
readonlyprotocolVersion:"actor-ts.io.broker.mqtt.protocol-version"='actor-ts.io.broker.mqtt.protocol-version'
io.broker.mqtt.qos
Section titled “io.broker.mqtt.qos”
readonlyqos:"actor-ts.io.broker.mqtt.qos"='actor-ts.io.broker.mqtt.qos'
io.broker.mqtt.root
Section titled “io.broker.mqtt.root”
readonlyroot:"actor-ts.io.broker.mqtt"='actor-ts.io.broker.mqtt'
io.broker.mqtt.will
Section titled “io.broker.mqtt.will”
readonlywill:object
io.broker.mqtt.will.payload
Section titled “io.broker.mqtt.will.payload”
readonlypayload:"actor-ts.io.broker.mqtt.will.payload"='actor-ts.io.broker.mqtt.will.payload'
io.broker.mqtt.will.qos
Section titled “io.broker.mqtt.will.qos”
readonlyqos:"actor-ts.io.broker.mqtt.will.qos"='actor-ts.io.broker.mqtt.will.qos'
io.broker.mqtt.will.retain
Section titled “io.broker.mqtt.will.retain”
readonlyretain:"actor-ts.io.broker.mqtt.will.retain"='actor-ts.io.broker.mqtt.will.retain'
io.broker.mqtt.will.root
Section titled “io.broker.mqtt.will.root”
readonlyroot:"actor-ts.io.broker.mqtt.will"='actor-ts.io.broker.mqtt.will'
io.broker.mqtt.will.topic
Section titled “io.broker.mqtt.will.topic”
readonlytopic:"actor-ts.io.broker.mqtt.will.topic"='actor-ts.io.broker.mqtt.will.topic'
io.broker.nats
Section titled “io.broker.nats”
readonlynats:object
NatsActor.
io.broker.nats.name
Section titled “io.broker.nats.name”
readonlyname:"actor-ts.io.broker.nats.name"='actor-ts.io.broker.nats.name'
io.broker.nats.password
Section titled “io.broker.nats.password”
readonlypassword:"actor-ts.io.broker.nats.password"='actor-ts.io.broker.nats.password'
io.broker.nats.root
Section titled “io.broker.nats.root”
readonlyroot:"actor-ts.io.broker.nats"='actor-ts.io.broker.nats'
io.broker.nats.servers
Section titled “io.broker.nats.servers”
readonlyservers:"actor-ts.io.broker.nats.servers"='actor-ts.io.broker.nats.servers'
io.broker.nats.token
Section titled “io.broker.nats.token”
readonlytoken:"actor-ts.io.broker.nats.token"='actor-ts.io.broker.nats.token'
io.broker.nats.user
Section titled “io.broker.nats.user”
readonlyuser:"actor-ts.io.broker.nats.user"='actor-ts.io.broker.nats.user'
io.broker.redisStreams
Section titled “io.broker.redisStreams”
readonlyredisStreams:object
RedisStreamsActor. consumer-group is read as a whole once it is
there: group and consumer are both required inside it.
io.broker.redisStreams.block
Section titled “io.broker.redisStreams.block”
readonlyblock:"actor-ts.io.broker.redis-streams.block"='actor-ts.io.broker.redis-streams.block'
io.broker.redisStreams.consumerGroup
Section titled “io.broker.redisStreams.consumerGroup”
readonlyconsumerGroup:object
io.broker.redisStreams.consumerGroup.consumer
Section titled “io.broker.redisStreams.consumerGroup.consumer”
readonlyconsumer:"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”
readonlycreateIfMissing:"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”
readonlygroup:"actor-ts.io.broker.redis-streams.consumer-group.group"='actor-ts.io.broker.redis-streams.consumer-group.group'
io.broker.redisStreams.consumerGroup.root
Section titled “io.broker.redisStreams.consumerGroup.root”
readonlyroot:"actor-ts.io.broker.redis-streams.consumer-group"='actor-ts.io.broker.redis-streams.consumer-group'
io.broker.redisStreams.root
Section titled “io.broker.redisStreams.root”
readonlyroot:"actor-ts.io.broker.redis-streams"='actor-ts.io.broker.redis-streams'
io.broker.redisStreams.streams
Section titled “io.broker.redisStreams.streams”
readonlystreams:"actor-ts.io.broker.redis-streams.streams"='actor-ts.io.broker.redis-streams.streams'
io.broker.redisStreams.url
Section titled “io.broker.redisStreams.url”
readonlyurl:"actor-ts.io.broker.redis-streams.url"='actor-ts.io.broker.redis-streams.url'
io.broker.sse
Section titled “io.broker.sse”
readonlysse:object
SseActor. headers is a block of header names, read whole.
io.broker.sse.connectTimeout
Section titled “io.broker.sse.connectTimeout”
readonlyconnectTimeout:"actor-ts.io.broker.sse.connect-timeout"='actor-ts.io.broker.sse.connect-timeout'
io.broker.sse.headers
Section titled “io.broker.sse.headers”
readonlyheaders:"actor-ts.io.broker.sse.headers"='actor-ts.io.broker.sse.headers'
io.broker.sse.idleTimeout
Section titled “io.broker.sse.idleTimeout”
readonlyidleTimeout:"actor-ts.io.broker.sse.idle-timeout"='actor-ts.io.broker.sse.idle-timeout'
io.broker.sse.root
Section titled “io.broker.sse.root”
readonlyroot:"actor-ts.io.broker.sse"='actor-ts.io.broker.sse'
io.broker.sse.url
Section titled “io.broker.sse.url”
readonlyurl:"actor-ts.io.broker.sse.url"='actor-ts.io.broker.sse.url'
io.broker.tcp
Section titled “io.broker.tcp”
readonlytcp:object
TcpSocketActor. framing is the block both TCP actors carry, so its
leaves come from tcpFramingKeysUnder under each root, and
readFramingFromConfig reads either copy.
io.broker.tcp.connectTimeout
Section titled “io.broker.tcp.connectTimeout”
readonlyconnectTimeout:"actor-ts.io.broker.tcp.connect-timeout"='actor-ts.io.broker.tcp.connect-timeout'
io.broker.tcp.framing
Section titled “io.broker.tcp.framing”
readonlyframing:object
io.broker.tcp.framing.delimiter
Section titled “io.broker.tcp.framing.delimiter”
readonlydelimiter:"actor-ts.io.broker.tcp.framing.delimiter"
io.broker.tcp.framing.kind
Section titled “io.broker.tcp.framing.kind”
readonlykind:"actor-ts.io.broker.tcp.framing.kind"
io.broker.tcp.framing.maxFrameBytes
Section titled “io.broker.tcp.framing.maxFrameBytes”
readonlymaxFrameBytes:"actor-ts.io.broker.tcp.framing.max-frame-bytes"
io.broker.tcp.framing.maxLineBytes
Section titled “io.broker.tcp.framing.maxLineBytes”
readonlymaxLineBytes:"actor-ts.io.broker.tcp.framing.max-line-bytes"
io.broker.tcp.framing.root
Section titled “io.broker.tcp.framing.root”root:
"actor-ts.io.broker.tcp.framing"
io.broker.tcp.host
Section titled “io.broker.tcp.host”
readonlyhost:"actor-ts.io.broker.tcp.host"='actor-ts.io.broker.tcp.host'
io.broker.tcp.idleTimeout
Section titled “io.broker.tcp.idleTimeout”
readonlyidleTimeout:"actor-ts.io.broker.tcp.idle-timeout"='actor-ts.io.broker.tcp.idle-timeout'
io.broker.tcp.keepAlive
Section titled “io.broker.tcp.keepAlive”
readonlykeepAlive:"actor-ts.io.broker.tcp.keep-alive"='actor-ts.io.broker.tcp.keep-alive'
io.broker.tcp.port
Section titled “io.broker.tcp.port”
readonlyport:"actor-ts.io.broker.tcp.port"='actor-ts.io.broker.tcp.port'
io.broker.tcp.root
Section titled “io.broker.tcp.root”
readonlyroot:"actor-ts.io.broker.tcp"='actor-ts.io.broker.tcp'
io.broker.tcpServer
Section titled “io.broker.tcpServer”
readonlytcpServer: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.
io.broker.tcpServer.bindHost
Section titled “io.broker.tcpServer.bindHost”
readonlybindHost:"actor-ts.io.broker.tcp-server.bind-host"='actor-ts.io.broker.tcp-server.bind-host'
io.broker.tcpServer.bindPort
Section titled “io.broker.tcpServer.bindPort”
readonlybindPort:"actor-ts.io.broker.tcp-server.bind-port"='actor-ts.io.broker.tcp-server.bind-port'
io.broker.tcpServer.framing
Section titled “io.broker.tcpServer.framing”
readonlyframing:object
io.broker.tcpServer.framing.delimiter
Section titled “io.broker.tcpServer.framing.delimiter”
readonlydelimiter:"actor-ts.io.broker.tcp-server.framing.delimiter"
io.broker.tcpServer.framing.kind
Section titled “io.broker.tcpServer.framing.kind”
readonlykind:"actor-ts.io.broker.tcp-server.framing.kind"
io.broker.tcpServer.framing.maxFrameBytes
Section titled “io.broker.tcpServer.framing.maxFrameBytes”
readonlymaxFrameBytes:"actor-ts.io.broker.tcp-server.framing.max-frame-bytes"
io.broker.tcpServer.framing.maxLineBytes
Section titled “io.broker.tcpServer.framing.maxLineBytes”
readonlymaxLineBytes:"actor-ts.io.broker.tcp-server.framing.max-line-bytes"
io.broker.tcpServer.framing.root
Section titled “io.broker.tcpServer.framing.root”root:
"actor-ts.io.broker.tcp-server.framing"
io.broker.tcpServer.maxConnections
Section titled “io.broker.tcpServer.maxConnections”
readonlymaxConnections:"actor-ts.io.broker.tcp-server.max-connections"='actor-ts.io.broker.tcp-server.max-connections'
The admission cap; unset means unlimited.
io.broker.tcpServer.root
Section titled “io.broker.tcpServer.root”
readonlyroot:"actor-ts.io.broker.tcp-server"='actor-ts.io.broker.tcp-server'
io.broker.udp
Section titled “io.broker.udp”
readonlyudp:object
UdpSocketActor.
io.broker.udp.bindHost
Section titled “io.broker.udp.bindHost”
readonlybindHost:"actor-ts.io.broker.udp.bind-host"='actor-ts.io.broker.udp.bind-host'
io.broker.udp.bindPort
Section titled “io.broker.udp.bindPort”
readonlybindPort:"actor-ts.io.broker.udp.bind-port"='actor-ts.io.broker.udp.bind-port'
io.broker.udp.root
Section titled “io.broker.udp.root”
readonlyroot:"actor-ts.io.broker.udp"='actor-ts.io.broker.udp'
io.broker.udp.type
Section titled “io.broker.udp.type”
readonlytype:"actor-ts.io.broker.udp.type"='actor-ts.io.broker.udp.type'
io.broker.websocket
Section titled “io.broker.websocket”
readonlywebsocket: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.
io.broker.websocket.connectTimeout
Section titled “io.broker.websocket.connectTimeout”
readonlyconnectTimeout:"actor-ts.io.broker.websocket.connect-timeout"='actor-ts.io.broker.websocket.connect-timeout'
io.broker.websocket.idleTimeout
Section titled “io.broker.websocket.idleTimeout”
readonlyidleTimeout:"actor-ts.io.broker.websocket.idle-timeout"='actor-ts.io.broker.websocket.idle-timeout'
io.broker.websocket.inboundHighWaterMark
Section titled “io.broker.websocket.inboundHighWaterMark”
readonlyinboundHighWaterMark:"actor-ts.io.broker.websocket.inbound-high-water-mark"='actor-ts.io.broker.websocket.inbound-high-water-mark'
io.broker.websocket.inboundLowWaterMark
Section titled “io.broker.websocket.inboundLowWaterMark”
readonlyinboundLowWaterMark:"actor-ts.io.broker.websocket.inbound-low-water-mark"='actor-ts.io.broker.websocket.inbound-low-water-mark'
io.broker.websocket.maxFrameBytes
Section titled “io.broker.websocket.maxFrameBytes”
readonlymaxFrameBytes:"actor-ts.io.broker.websocket.max-frame-bytes"='actor-ts.io.broker.websocket.max-frame-bytes'
io.broker.websocket.onInvalidMessage
Section titled “io.broker.websocket.onInvalidMessage”
readonlyonInvalidMessage:"actor-ts.io.broker.websocket.on-invalid-message"='actor-ts.io.broker.websocket.on-invalid-message'
io.broker.websocket.pingInterval
Section titled “io.broker.websocket.pingInterval”
readonlypingInterval:"actor-ts.io.broker.websocket.ping-interval"='actor-ts.io.broker.websocket.ping-interval'
io.broker.websocket.protocols
Section titled “io.broker.websocket.protocols”
readonlyprotocols:"actor-ts.io.broker.websocket.protocols"='actor-ts.io.broker.websocket.protocols'
io.broker.websocket.root
Section titled “io.broker.websocket.root”
readonlyroot:"actor-ts.io.broker.websocket"='actor-ts.io.broker.websocket'
io.broker.websocket.url
Section titled “io.broker.websocket.url”
readonlyurl:"actor-ts.io.broker.websocket.url"='actor-ts.io.broker.websocket.url'
logger
Section titled “logger”
readonlylogger:object
Logger root — actor-ts.logger.*.
logger.closeTimeout
Section titled “logger.closeTimeout”
readonlycloseTimeout:"actor-ts.logger.close-timeout"='actor-ts.logger.close-timeout'
logger.level
Section titled “logger.level”
readonlylevel:"actor-ts.logger.level"='actor-ts.logger.level'
logger.sinks
Section titled “logger.sinks”
readonlysinks: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.
logger.sinks.console
Section titled “logger.sinks.console”
readonlyconsole:"actor-ts.logger.sinks.console"='actor-ts.logger.sinks.console'
logger.sinks.file
Section titled “logger.sinks.file”
readonlyfile:"actor-ts.logger.sinks.file"='actor-ts.logger.sinks.file'
logger.sinks.gelf
Section titled “logger.sinks.gelf”
readonlygelf:"actor-ts.logger.sinks.gelf"='actor-ts.logger.sinks.gelf'
logger.sinks.loki
Section titled “logger.sinks.loki”
readonlyloki:"actor-ts.logger.sinks.loki"='actor-ts.logger.sinks.loki'
logger.sinks.otlp
Section titled “logger.sinks.otlp”
readonlyotlp:"actor-ts.logger.sinks.otlp"='actor-ts.logger.sinks.otlp'
logger.sinks.parseable
Section titled “logger.sinks.parseable”
readonlyparseable:"actor-ts.logger.sinks.parseable"='actor-ts.logger.sinks.parseable'
logger.sinks.seq
Section titled “logger.sinks.seq”
readonlyseq:"actor-ts.logger.sinks.seq"='actor-ts.logger.sinks.seq'
logger.sinks.splunk
Section titled “logger.sinks.splunk”
readonlysplunk:"actor-ts.logger.sinks.splunk"='actor-ts.logger.sinks.splunk'
logger.sinks.syslog
Section titled “logger.sinks.syslog”
readonlysyslog:"actor-ts.logger.sinks.syslog"='actor-ts.logger.sinks.syslog'
mailbox
Section titled “mailbox”
readonlymailbox: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.
mailbox.default
Section titled “mailbox.default”
readonlydefault:object
mailbox.default.capacity
Section titled “mailbox.default.capacity”
readonlycapacity:"actor-ts.mailbox.default.capacity"='actor-ts.mailbox.default.capacity'
mailbox.default.overflow
Section titled “mailbox.default.overflow”
readonlyoverflow:"actor-ts.mailbox.default.overflow"='actor-ts.mailbox.default.overflow'
management
Section titled “management”
readonlymanagement: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.
management.authProtectHealth
Section titled “management.authProtectHealth”
readonlyauthProtectHealth:"actor-ts.management.auth-protect-health"='actor-ts.management.auth-protect-health'
management.enableDownEndpoint
Section titled “management.enableDownEndpoint”
readonlyenableDownEndpoint:"actor-ts.management.enable-down-endpoint"='actor-ts.management.enable-down-endpoint'
management.enableLeaveEndpoint
Section titled “management.enableLeaveEndpoint”
readonlyenableLeaveEndpoint:"actor-ts.management.enable-leave-endpoint"='actor-ts.management.enable-leave-endpoint'
management.enableMetricsEndpoint
Section titled “management.enableMetricsEndpoint”
readonlyenableMetricsEndpoint:"actor-ts.management.enable-metrics-endpoint"='actor-ts.management.enable-metrics-endpoint'
management.healthChecks
Section titled “management.healthChecks”
readonlyhealthChecks:object
management.healthChecks.checkTimeout
Section titled “management.healthChecks.checkTimeout”
readonlycheckTimeout:"actor-ts.management.health-checks.check-timeout"='actor-ts.management.health-checks.check-timeout'
management.livenessPath
Section titled “management.livenessPath”
readonlylivenessPath:"actor-ts.management.liveness-path"='actor-ts.management.liveness-path'
management.readinessPath
Section titled “management.readinessPath”
readonlyreadinessPath:"actor-ts.management.readiness-path"='actor-ts.management.readiness-path'
messageBoundary
Section titled “messageBoundary”
readonlymessageBoundary: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.
messageBoundary.serializerRoundTrip
Section titled “messageBoundary.serializerRoundTrip”
readonlyserializerRoundTrip:"actor-ts.diagnostics.message-boundary.serializer-round-trip"='actor-ts.diagnostics.message-boundary.serializer-round-trip'
messageBoundary.structuredClone
Section titled “messageBoundary.structuredClone”
readonlystructuredClone:"actor-ts.diagnostics.message-boundary.structured-clone"='actor-ts.diagnostics.message-boundary.structured-clone'
metrics
Section titled “metrics”
readonlymetrics: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.
metrics.maxSeriesPerFamily
Section titled “metrics.maxSeriesPerFamily”
readonlymaxSeriesPerFamily:"actor-ts.metrics.max-series-per-family"='actor-ts.metrics.max-series-per-family'
metrics.namePrefix
Section titled “metrics.namePrefix”
readonlynamePrefix:"actor-ts.metrics.name-prefix"='actor-ts.metrics.name-prefix'
offloadPool
Section titled “offloadPool”
readonlyoffloadPool:object
The function-level offload pool — actor-ts.offload-pool.* (#1558).
offloadPool.idleTimeout
Section titled “offloadPool.idleTimeout”
readonlyidleTimeout:"actor-ts.offload-pool.idle-timeout"='actor-ts.offload-pool.idle-timeout'
offloadPool.maxQueue
Section titled “offloadPool.maxQueue”
readonlymaxQueue:"actor-ts.offload-pool.max-queue"='actor-ts.offload-pool.max-queue'
offloadPool.maxRestarts
Section titled “offloadPool.maxRestarts”
readonlymaxRestarts:"actor-ts.offload-pool.max-restarts"='actor-ts.offload-pool.max-restarts'
offloadPool.minSize
Section titled “offloadPool.minSize”
readonlyminSize:"actor-ts.offload-pool.min-size"='actor-ts.offload-pool.min-size'
offloadPool.overflow
Section titled “offloadPool.overflow”
readonlyoverflow:"actor-ts.offload-pool.overflow"='actor-ts.offload-pool.overflow'
offloadPool.restartWindow
Section titled “offloadPool.restartWindow”
readonlyrestartWindow:"actor-ts.offload-pool.restart-window"='actor-ts.offload-pool.restart-window'
offloadPool.size
Section titled “offloadPool.size”
readonlysize:"actor-ts.offload-pool.size"='actor-ts.offload-pool.size'
offloadPool.taskTimeout
Section titled “offloadPool.taskTimeout”
readonlytaskTimeout:"actor-ts.offload-pool.task-timeout"='actor-ts.offload-pool.task-timeout'
offloadPool.warmUp
Section titled “offloadPool.warmUp”
readonlywarmUp:"actor-ts.offload-pool.warm-up"='actor-ts.offload-pool.warm-up'
parallelism
Section titled “parallelism”
readonlyparallelism:object
Actors on worker threads from configuration alone — actor-ts.parallelism.* (#1563).
parallelism.bufferSize
Section titled “parallelism.bufferSize”
readonlybufferSize:"actor-ts.parallelism.buffer-size"='actor-ts.parallelism.buffer-size'
parallelism.leader
Section titled “parallelism.leader”
readonlyleader:"actor-ts.parallelism.leader"='actor-ts.parallelism.leader'
parallelism.offload
Section titled “parallelism.offload”
readonlyoffload:"actor-ts.parallelism.offload"='actor-ts.parallelism.offload'
parallelism.placement
Section titled “parallelism.placement”
readonlyplacement:"actor-ts.parallelism.placement"='actor-ts.parallelism.placement'
parallelism.spawnTimeout
Section titled “parallelism.spawnTimeout”
readonlyspawnTimeout:"actor-ts.parallelism.spawn-timeout"='actor-ts.parallelism.spawn-timeout'
parallelism.workers
Section titled “parallelism.workers”
readonlyworkers:"actor-ts.parallelism.workers"='actor-ts.parallelism.workers'
persistence
Section titled “persistence”
readonlypersistence:object
Persistence plugin selection + config — actor-ts.persistence.*.
persistence.autoStart
Section titled “persistence.autoStart”
readonlyautoStart:"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.
persistence.durableState
Section titled “persistence.durableState”
readonlydurableState: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.
persistence.durableState.cloudflareD1
Section titled “persistence.durableState.cloudflareD1”
readonlycloudflareD1:object
The Cloudflare D1 durable-state store’s block — see postgres.
persistence.durableState.cloudflareD1.accountId
Section titled “persistence.durableState.cloudflareD1.accountId”
readonlyaccountId:"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”
readonlyapiToken:"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”
readonlyautoCreateTables:"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”
readonlybaseUrl:"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”
readonlydatabaseId:"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”
readonlymaxResponseBytes:"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”
readonlyroot:"actor-ts.persistence.durable-state.cloudflare-d1"='actor-ts.persistence.durable-state.cloudflare-d1'
persistence.durableState.cloudflareD1.table
Section titled “persistence.durableState.cloudflareD1.table”
readonlytable:"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”
readonlytimeout:"actor-ts.persistence.durable-state.cloudflare-d1.timeout"='actor-ts.persistence.durable-state.cloudflare-d1.timeout'
persistence.durableState.dynamodb
Section titled “persistence.durableState.dynamodb”
readonlydynamodb: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”
readonlyautoCreateTables:"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”
readonlybillingMode:"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”
readonlyconnectionTimeout:"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”
readonlyendpoint:"actor-ts.persistence.durable-state.dynamodb.endpoint"='actor-ts.persistence.durable-state.dynamodb.endpoint'
persistence.durableState.dynamodb.maxAttempts
Section titled “persistence.durableState.dynamodb.maxAttempts”
readonlymaxAttempts:"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”
readonlyprovisionedThroughputReadCapacityUnits:"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”
readonlyprovisionedThroughputWriteCapacityUnits:"actor-ts.persistence.durable-state.dynamodb.provisioned-throughput.write-capacity-units"='actor-ts.persistence.durable-state.dynamodb.provisioned-throughput.write-capacity-units'
persistence.durableState.dynamodb.region
Section titled “persistence.durableState.dynamodb.region”
readonlyregion:"actor-ts.persistence.durable-state.dynamodb.region"='actor-ts.persistence.durable-state.dynamodb.region'
persistence.durableState.dynamodb.requestTimeout
Section titled “persistence.durableState.dynamodb.requestTimeout”
readonlyrequestTimeout:"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”
readonlyretryMode:"actor-ts.persistence.durable-state.dynamodb.retry-mode"='actor-ts.persistence.durable-state.dynamodb.retry-mode'
persistence.durableState.dynamodb.root
Section titled “persistence.durableState.dynamodb.root”
readonlyroot:"actor-ts.persistence.durable-state.dynamodb"='actor-ts.persistence.durable-state.dynamodb'
persistence.durableState.dynamodb.table
Section titled “persistence.durableState.dynamodb.table”
readonlytable:"actor-ts.persistence.durable-state.dynamodb.table"='actor-ts.persistence.durable-state.dynamodb.table'
persistence.durableState.dynamodb.tableReadyTimeout
Section titled “persistence.durableState.dynamodb.tableReadyTimeout”
readonlytableReadyTimeout:"actor-ts.persistence.durable-state.dynamodb.table-ready-timeout"='actor-ts.persistence.durable-state.dynamodb.table-ready-timeout'
persistence.durableState.inMemory
Section titled “persistence.durableState.inMemory”
readonlyinMemory:"actor-ts.persistence.durable-state.in-memory"='actor-ts.persistence.durable-state.in-memory'
persistence.durableState.libsql
Section titled “persistence.durableState.libsql”
readonlylibsql:object
The libSQL durable-state store’s block — see postgres.
persistence.durableState.libsql.authToken
Section titled “persistence.durableState.libsql.authToken”
readonlyauthToken:"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”
readonlyautoCreateTables:"actor-ts.persistence.durable-state.libsql.auto-create-tables"='actor-ts.persistence.durable-state.libsql.auto-create-tables'
persistence.durableState.libsql.root
Section titled “persistence.durableState.libsql.root”
readonlyroot:"actor-ts.persistence.durable-state.libsql"='actor-ts.persistence.durable-state.libsql'
persistence.durableState.libsql.table
Section titled “persistence.durableState.libsql.table”
readonlytable:"actor-ts.persistence.durable-state.libsql.table"='actor-ts.persistence.durable-state.libsql.table'
persistence.durableState.libsql.url
Section titled “persistence.durableState.libsql.url”
readonlyurl:"actor-ts.persistence.durable-state.libsql.url"='actor-ts.persistence.durable-state.libsql.url'
persistence.durableState.mariadb
Section titled “persistence.durableState.mariadb”
readonlymariadb:object
The MariaDB durable-state store’s block — see postgres.
persistence.durableState.mariadb.acquireTimeout
Section titled “persistence.durableState.mariadb.acquireTimeout”
readonlyacquireTimeout:"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”
readonlyautoCreateTables:"actor-ts.persistence.durable-state.mariadb.auto-create-tables"='actor-ts.persistence.durable-state.mariadb.auto-create-tables'
persistence.durableState.mariadb.caFile
Section titled “persistence.durableState.mariadb.caFile”
readonlycaFile:"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”
readonlyconnectTimeout:"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”
readonlyidleTimeout:"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”
readonlymaxPoolSize:"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.
persistence.durableState.mariadb.root
Section titled “persistence.durableState.mariadb.root”
readonlyroot:"actor-ts.persistence.durable-state.mariadb"='actor-ts.persistence.durable-state.mariadb'
persistence.durableState.mariadb.table
Section titled “persistence.durableState.mariadb.table”
readonlytable:"actor-ts.persistence.durable-state.mariadb.table"='actor-ts.persistence.durable-state.mariadb.table'
persistence.durableState.mariadb.url
Section titled “persistence.durableState.mariadb.url”
readonlyurl:"actor-ts.persistence.durable-state.mariadb.url"='actor-ts.persistence.durable-state.mariadb.url'
persistence.durableState.mongodb
Section titled “persistence.durableState.mongodb”
readonlymongodb:object
The MongoDB durable-state store’s block - see journal’s mongodb.
persistence.durableState.mongodb.caFile
Section titled “persistence.durableState.mongodb.caFile”
readonlycaFile:"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”
readonlycollection:"actor-ts.persistence.durable-state.mongodb.collection"='actor-ts.persistence.durable-state.mongodb.collection'
persistence.durableState.mongodb.connectTimeout
Section titled “persistence.durableState.mongodb.connectTimeout”
readonlyconnectTimeout:"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”
readonlydatabaseName:"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”
readonlymaxPoolSize:"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”
readonlyminPoolSize:"actor-ts.persistence.durable-state.mongodb.min-pool-size"='actor-ts.persistence.durable-state.mongodb.min-pool-size'
persistence.durableState.mongodb.root
Section titled “persistence.durableState.mongodb.root”
readonlyroot:"actor-ts.persistence.durable-state.mongodb"='actor-ts.persistence.durable-state.mongodb'
persistence.durableState.mongodb.serverSelectionTimeout
Section titled “persistence.durableState.mongodb.serverSelectionTimeout”
readonlyserverSelectionTimeout:"actor-ts.persistence.durable-state.mongodb.server-selection-timeout"='actor-ts.persistence.durable-state.mongodb.server-selection-timeout'
persistence.durableState.mongodb.url
Section titled “persistence.durableState.mongodb.url”
readonlyurl:"actor-ts.persistence.durable-state.mongodb.url"='actor-ts.persistence.durable-state.mongodb.url'
persistence.durableState.mssql
Section titled “persistence.durableState.mssql”
readonlymssql:object
The SQL Server durable-state store’s block — see postgres.
persistence.durableState.mssql.autoCreateTables
Section titled “persistence.durableState.mssql.autoCreateTables”
readonlyautoCreateTables:"actor-ts.persistence.durable-state.mssql.auto-create-tables"='actor-ts.persistence.durable-state.mssql.auto-create-tables'
persistence.durableState.mssql.caFile
Section titled “persistence.durableState.mssql.caFile”
readonlycaFile:"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”
readonlyconnectTimeout:"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”
readonlyidleTimeout:"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”
readonlymaxPoolSize:"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”
readonlyrequestTimeout:"actor-ts.persistence.durable-state.mssql.request-timeout"='actor-ts.persistence.durable-state.mssql.request-timeout'
persistence.durableState.mssql.root
Section titled “persistence.durableState.mssql.root”
readonlyroot:"actor-ts.persistence.durable-state.mssql"='actor-ts.persistence.durable-state.mssql'
persistence.durableState.mssql.table
Section titled “persistence.durableState.mssql.table”
readonlytable:"actor-ts.persistence.durable-state.mssql.table"='actor-ts.persistence.durable-state.mssql.table'
persistence.durableState.mssql.url
Section titled “persistence.durableState.mssql.url”
readonlyurl:"actor-ts.persistence.durable-state.mssql.url"='actor-ts.persistence.durable-state.mssql.url'
persistence.durableState.objectStorage
Section titled “persistence.durableState.objectStorage”
readonlyobjectStorage:"actor-ts.persistence.durable-state.object-storage"='actor-ts.persistence.durable-state.object-storage'
persistence.durableState.plugin
Section titled “persistence.durableState.plugin”
readonlyplugin:"actor-ts.persistence.durable-state.plugin"='actor-ts.persistence.durable-state.plugin'
persistence.durableState.postgres
Section titled “persistence.durableState.postgres”
readonlypostgres: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”
readonlyautoCreateTables:"actor-ts.persistence.durable-state.postgres.auto-create-tables"='actor-ts.persistence.durable-state.postgres.auto-create-tables'
persistence.durableState.postgres.caFile
Section titled “persistence.durableState.postgres.caFile”
readonlycaFile:"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”
readonlyconnectTimeout:"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”
readonlyidleTimeout:"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”
readonlymaxPoolSize:"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.
persistence.durableState.postgres.root
Section titled “persistence.durableState.postgres.root”
readonlyroot:"actor-ts.persistence.durable-state.postgres"='actor-ts.persistence.durable-state.postgres'
persistence.durableState.postgres.table
Section titled “persistence.durableState.postgres.table”
readonlytable:"actor-ts.persistence.durable-state.postgres.table"='actor-ts.persistence.durable-state.postgres.table'
persistence.durableState.postgres.url
Section titled “persistence.durableState.postgres.url”
readonlyurl:"actor-ts.persistence.durable-state.postgres.url"='actor-ts.persistence.durable-state.postgres.url'
persistence.durableState.sqlite
Section titled “persistence.durableState.sqlite”
readonlysqlite:object
The SQLite durable-state store’s block — see journal’s sqlite.
persistence.durableState.sqlite.autoCreateTables
Section titled “persistence.durableState.sqlite.autoCreateTables”
readonlyautoCreateTables:"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”
readonlybusyTimeout:"actor-ts.persistence.durable-state.sqlite.busy-timeout"='actor-ts.persistence.durable-state.sqlite.busy-timeout'
persistence.durableState.sqlite.path
Section titled “persistence.durableState.sqlite.path”
readonlypath:"actor-ts.persistence.durable-state.sqlite.path"='actor-ts.persistence.durable-state.sqlite.path'
persistence.durableState.sqlite.root
Section titled “persistence.durableState.sqlite.root”
readonlyroot:"actor-ts.persistence.durable-state.sqlite"='actor-ts.persistence.durable-state.sqlite'
persistence.durableState.sqlite.table
Section titled “persistence.durableState.sqlite.table”
readonlytable:"actor-ts.persistence.durable-state.sqlite.table"='actor-ts.persistence.durable-state.sqlite.table'
persistence.journal
Section titled “persistence.journal”
readonlyjournal:object
persistence.journal.cassandra
Section titled “persistence.journal.cassandra”
readonlycassandra: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).
persistence.journal.cassandra.allIdsTable
Section titled “persistence.journal.cassandra.allIdsTable”
readonlyallIdsTable:"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”
readonlyautoCreateKeyspace:"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”
readonlyautoCreateTables:"actor-ts.persistence.journal.cassandra.auto-create-tables"='actor-ts.persistence.journal.cassandra.auto-create-tables'
persistence.journal.cassandra.consistency
Section titled “persistence.journal.cassandra.consistency”
readonlyconsistency:"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”
readonlycontactPoints:"actor-ts.persistence.journal.cassandra.contact-points"='actor-ts.persistence.journal.cassandra.contact-points'
persistence.journal.cassandra.eventsTable
Section titled “persistence.journal.cassandra.eventsTable”
readonlyeventsTable:"actor-ts.persistence.journal.cassandra.events-table"='actor-ts.persistence.journal.cassandra.events-table'
persistence.journal.cassandra.keyspace
Section titled “persistence.journal.cassandra.keyspace”
readonlykeyspace:"actor-ts.persistence.journal.cassandra.keyspace"='actor-ts.persistence.journal.cassandra.keyspace'
persistence.journal.cassandra.lightweightTransactions
Section titled “persistence.journal.cassandra.lightweightTransactions”
readonlylightweightTransactions:"actor-ts.persistence.journal.cassandra.lightweight-transactions"='actor-ts.persistence.journal.cassandra.lightweight-transactions'
persistence.journal.cassandra.localDataCenter
Section titled “persistence.journal.cassandra.localDataCenter”
readonlylocalDataCenter:"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”
readonlymetadataTable:"actor-ts.persistence.journal.cassandra.metadata-table"='actor-ts.persistence.journal.cassandra.metadata-table'
persistence.journal.cassandra.partitionSize
Section titled “persistence.journal.cassandra.partitionSize”
readonlypartitionSize:"actor-ts.persistence.journal.cassandra.partition-size"='actor-ts.persistence.journal.cassandra.partition-size'
persistence.journal.cassandra.port
Section titled “persistence.journal.cassandra.port”
readonlyport:"actor-ts.persistence.journal.cassandra.port"='actor-ts.persistence.journal.cassandra.port'
persistence.journal.cassandra.replicationClass
Section titled “persistence.journal.cassandra.replicationClass”
readonlyreplicationClass:"actor-ts.persistence.journal.cassandra.replication.class"='actor-ts.persistence.journal.cassandra.replication.class'
persistence.journal.cassandra.replicationDataCenters
Section titled “persistence.journal.cassandra.replicationDataCenters”
readonlyreplicationDataCenters:"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”
readonlyreplicationFactor:"actor-ts.persistence.journal.cassandra.replication.replication-factor"='actor-ts.persistence.journal.cassandra.replication.replication-factor'
persistence.journal.cassandra.root
Section titled “persistence.journal.cassandra.root”
readonlyroot:"actor-ts.persistence.journal.cassandra"='actor-ts.persistence.journal.cassandra'
persistence.journal.cassandra.serialConsistency
Section titled “persistence.journal.cassandra.serialConsistency”
readonlyserialConsistency:"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”
readonlytagIndexTable:"actor-ts.persistence.journal.cassandra.tag-index-table"='actor-ts.persistence.journal.cassandra.tag-index-table'
persistence.journal.cassandra.useTagIndex
Section titled “persistence.journal.cassandra.useTagIndex”
readonlyuseTagIndex:"actor-ts.persistence.journal.cassandra.use-tag-index"='actor-ts.persistence.journal.cassandra.use-tag-index'
persistence.journal.cloudflareD1
Section titled “persistence.journal.cloudflareD1”
readonlycloudflareD1: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”
readonlyaccountId:"actor-ts.persistence.journal.cloudflare-d1.account-id"='actor-ts.persistence.journal.cloudflare-d1.account-id'
persistence.journal.cloudflareD1.apiToken
Section titled “persistence.journal.cloudflareD1.apiToken”
readonlyapiToken:"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”
readonlyautoCreateTables:"actor-ts.persistence.journal.cloudflare-d1.auto-create-tables"='actor-ts.persistence.journal.cloudflare-d1.auto-create-tables'
persistence.journal.cloudflareD1.baseUrl
Section titled “persistence.journal.cloudflareD1.baseUrl”
readonlybaseUrl:"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”
readonlydatabaseId:"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”
readonlyeventsTable:"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”
readonlymaxResponseBytes:"actor-ts.persistence.journal.cloudflare-d1.max-response-bytes"='actor-ts.persistence.journal.cloudflare-d1.max-response-bytes'
persistence.journal.cloudflareD1.root
Section titled “persistence.journal.cloudflareD1.root”
readonlyroot:"actor-ts.persistence.journal.cloudflare-d1"='actor-ts.persistence.journal.cloudflare-d1'
persistence.journal.cloudflareD1.tagsTable
Section titled “persistence.journal.cloudflareD1.tagsTable”
readonlytagsTable:"actor-ts.persistence.journal.cloudflare-d1.tags-table"='actor-ts.persistence.journal.cloudflare-d1.tags-table'
persistence.journal.cloudflareD1.timeout
Section titled “persistence.journal.cloudflareD1.timeout”
readonlytimeout:"actor-ts.persistence.journal.cloudflare-d1.timeout"='actor-ts.persistence.journal.cloudflare-d1.timeout'
persistence.journal.dynamodb
Section titled “persistence.journal.dynamodb”
readonlydynamodb: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”
readonlyautoCreateTables:"actor-ts.persistence.journal.dynamodb.auto-create-tables"='actor-ts.persistence.journal.dynamodb.auto-create-tables'
persistence.journal.dynamodb.billingMode
Section titled “persistence.journal.dynamodb.billingMode”
readonlybillingMode:"actor-ts.persistence.journal.dynamodb.billing-mode"='actor-ts.persistence.journal.dynamodb.billing-mode'
persistence.journal.dynamodb.connectionTimeout
Section titled “persistence.journal.dynamodb.connectionTimeout”
readonlyconnectionTimeout:"actor-ts.persistence.journal.dynamodb.connection-timeout"='actor-ts.persistence.journal.dynamodb.connection-timeout'
persistence.journal.dynamodb.endpoint
Section titled “persistence.journal.dynamodb.endpoint”
readonlyendpoint:"actor-ts.persistence.journal.dynamodb.endpoint"='actor-ts.persistence.journal.dynamodb.endpoint'
persistence.journal.dynamodb.eventsTable
Section titled “persistence.journal.dynamodb.eventsTable”
readonlyeventsTable:"actor-ts.persistence.journal.dynamodb.events-table"='actor-ts.persistence.journal.dynamodb.events-table'
persistence.journal.dynamodb.maxAttempts
Section titled “persistence.journal.dynamodb.maxAttempts”
readonlymaxAttempts:"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”
readonlyprovisionedThroughputReadCapacityUnits:"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”
readonlyprovisionedThroughputWriteCapacityUnits:"actor-ts.persistence.journal.dynamodb.provisioned-throughput.write-capacity-units"='actor-ts.persistence.journal.dynamodb.provisioned-throughput.write-capacity-units'
persistence.journal.dynamodb.region
Section titled “persistence.journal.dynamodb.region”
readonlyregion:"actor-ts.persistence.journal.dynamodb.region"='actor-ts.persistence.journal.dynamodb.region'
persistence.journal.dynamodb.requestTimeout
Section titled “persistence.journal.dynamodb.requestTimeout”
readonlyrequestTimeout:"actor-ts.persistence.journal.dynamodb.request-timeout"='actor-ts.persistence.journal.dynamodb.request-timeout'
persistence.journal.dynamodb.retryMode
Section titled “persistence.journal.dynamodb.retryMode”
readonlyretryMode:"actor-ts.persistence.journal.dynamodb.retry-mode"='actor-ts.persistence.journal.dynamodb.retry-mode'
persistence.journal.dynamodb.root
Section titled “persistence.journal.dynamodb.root”
readonlyroot:"actor-ts.persistence.journal.dynamodb"='actor-ts.persistence.journal.dynamodb'
persistence.journal.dynamodb.tableReadyTimeout
Section titled “persistence.journal.dynamodb.tableReadyTimeout”
readonlytableReadyTimeout:"actor-ts.persistence.journal.dynamodb.table-ready-timeout"='actor-ts.persistence.journal.dynamodb.table-ready-timeout'
persistence.journal.inMemory
Section titled “persistence.journal.inMemory”
readonlyinMemory:"actor-ts.persistence.journal.in-memory"='actor-ts.persistence.journal.in-memory'
persistence.journal.libsql
Section titled “persistence.journal.libsql”
readonlylibsql:object
The libSQL journal’s block — auth-token is the Turso credential.
persistence.journal.libsql.authToken
Section titled “persistence.journal.libsql.authToken”
readonlyauthToken:"actor-ts.persistence.journal.libsql.auth-token"='actor-ts.persistence.journal.libsql.auth-token'
persistence.journal.libsql.autoCreateTables
Section titled “persistence.journal.libsql.autoCreateTables”
readonlyautoCreateTables:"actor-ts.persistence.journal.libsql.auto-create-tables"='actor-ts.persistence.journal.libsql.auto-create-tables'
persistence.journal.libsql.eventsTable
Section titled “persistence.journal.libsql.eventsTable”
readonlyeventsTable:"actor-ts.persistence.journal.libsql.events-table"='actor-ts.persistence.journal.libsql.events-table'
persistence.journal.libsql.root
Section titled “persistence.journal.libsql.root”
readonlyroot:"actor-ts.persistence.journal.libsql"='actor-ts.persistence.journal.libsql'
persistence.journal.libsql.tagsTable
Section titled “persistence.journal.libsql.tagsTable”
readonlytagsTable:"actor-ts.persistence.journal.libsql.tags-table"='actor-ts.persistence.journal.libsql.tags-table'
persistence.journal.libsql.url
Section titled “persistence.journal.libsql.url”
readonlyurl:"actor-ts.persistence.journal.libsql.url"='actor-ts.persistence.journal.libsql.url'
persistence.journal.mariadb
Section titled “persistence.journal.mariadb”
readonlymariadb:object
The MariaDB journal’s block — see postgres.
persistence.journal.mariadb.acquireTimeout
Section titled “persistence.journal.mariadb.acquireTimeout”
readonlyacquireTimeout:"actor-ts.persistence.journal.mariadb.acquire-timeout"='actor-ts.persistence.journal.mariadb.acquire-timeout'
persistence.journal.mariadb.autoCreateTables
Section titled “persistence.journal.mariadb.autoCreateTables”
readonlyautoCreateTables:"actor-ts.persistence.journal.mariadb.auto-create-tables"='actor-ts.persistence.journal.mariadb.auto-create-tables'
persistence.journal.mariadb.caFile
Section titled “persistence.journal.mariadb.caFile”
readonlycaFile:"actor-ts.persistence.journal.mariadb.ca-file"='actor-ts.persistence.journal.mariadb.ca-file'
persistence.journal.mariadb.connectTimeout
Section titled “persistence.journal.mariadb.connectTimeout”
readonlyconnectTimeout:"actor-ts.persistence.journal.mariadb.connect-timeout"='actor-ts.persistence.journal.mariadb.connect-timeout'
persistence.journal.mariadb.eventsTable
Section titled “persistence.journal.mariadb.eventsTable”
readonlyeventsTable:"actor-ts.persistence.journal.mariadb.events-table"='actor-ts.persistence.journal.mariadb.events-table'
persistence.journal.mariadb.idleTimeout
Section titled “persistence.journal.mariadb.idleTimeout”
readonlyidleTimeout:"actor-ts.persistence.journal.mariadb.idle-timeout"='actor-ts.persistence.journal.mariadb.idle-timeout'
persistence.journal.mariadb.maxPoolSize
Section titled “persistence.journal.mariadb.maxPoolSize”
readonlymaxPoolSize:"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.
persistence.journal.mariadb.root
Section titled “persistence.journal.mariadb.root”
readonlyroot:"actor-ts.persistence.journal.mariadb"='actor-ts.persistence.journal.mariadb'
persistence.journal.mariadb.tagsTable
Section titled “persistence.journal.mariadb.tagsTable”
readonlytagsTable:"actor-ts.persistence.journal.mariadb.tags-table"='actor-ts.persistence.journal.mariadb.tags-table'
persistence.journal.mariadb.url
Section titled “persistence.journal.mariadb.url”
readonlyurl:"actor-ts.persistence.journal.mariadb.url"='actor-ts.persistence.journal.mariadb.url'
persistence.journal.mongodb
Section titled “persistence.journal.mongodb”
readonlymongodb: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”
readonlyautoCreateIndexes:"actor-ts.persistence.journal.mongodb.auto-create-indexes"='actor-ts.persistence.journal.mongodb.auto-create-indexes'
persistence.journal.mongodb.caFile
Section titled “persistence.journal.mongodb.caFile”
readonlycaFile:"actor-ts.persistence.journal.mongodb.ca-file"='actor-ts.persistence.journal.mongodb.ca-file'
persistence.journal.mongodb.connectTimeout
Section titled “persistence.journal.mongodb.connectTimeout”
readonlyconnectTimeout:"actor-ts.persistence.journal.mongodb.connect-timeout"='actor-ts.persistence.journal.mongodb.connect-timeout'
persistence.journal.mongodb.databaseName
Section titled “persistence.journal.mongodb.databaseName”
readonlydatabaseName:"actor-ts.persistence.journal.mongodb.database-name"='actor-ts.persistence.journal.mongodb.database-name'
persistence.journal.mongodb.eventsCollection
Section titled “persistence.journal.mongodb.eventsCollection”
readonlyeventsCollection:"actor-ts.persistence.journal.mongodb.events-collection"='actor-ts.persistence.journal.mongodb.events-collection'
persistence.journal.mongodb.maxPoolSize
Section titled “persistence.journal.mongodb.maxPoolSize”
readonlymaxPoolSize:"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.
persistence.journal.mongodb.minPoolSize
Section titled “persistence.journal.mongodb.minPoolSize”
readonlyminPoolSize:"actor-ts.persistence.journal.mongodb.min-pool-size"='actor-ts.persistence.journal.mongodb.min-pool-size'
persistence.journal.mongodb.root
Section titled “persistence.journal.mongodb.root”
readonlyroot:"actor-ts.persistence.journal.mongodb"='actor-ts.persistence.journal.mongodb'
persistence.journal.mongodb.serverSelectionTimeout
Section titled “persistence.journal.mongodb.serverSelectionTimeout”
readonlyserverSelectionTimeout:"actor-ts.persistence.journal.mongodb.server-selection-timeout"='actor-ts.persistence.journal.mongodb.server-selection-timeout'
persistence.journal.mongodb.url
Section titled “persistence.journal.mongodb.url”
readonlyurl:"actor-ts.persistence.journal.mongodb.url"='actor-ts.persistence.journal.mongodb.url'
persistence.journal.mssql
Section titled “persistence.journal.mssql”
readonlymssql:object
The SQL Server journal’s block — see postgres.
persistence.journal.mssql.autoCreateTables
Section titled “persistence.journal.mssql.autoCreateTables”
readonlyautoCreateTables:"actor-ts.persistence.journal.mssql.auto-create-tables"='actor-ts.persistence.journal.mssql.auto-create-tables'
persistence.journal.mssql.caFile
Section titled “persistence.journal.mssql.caFile”
readonlycaFile:"actor-ts.persistence.journal.mssql.ca-file"='actor-ts.persistence.journal.mssql.ca-file'
persistence.journal.mssql.connectTimeout
Section titled “persistence.journal.mssql.connectTimeout”
readonlyconnectTimeout:"actor-ts.persistence.journal.mssql.connect-timeout"='actor-ts.persistence.journal.mssql.connect-timeout'
persistence.journal.mssql.eventsTable
Section titled “persistence.journal.mssql.eventsTable”
readonlyeventsTable:"actor-ts.persistence.journal.mssql.events-table"='actor-ts.persistence.journal.mssql.events-table'
persistence.journal.mssql.idleTimeout
Section titled “persistence.journal.mssql.idleTimeout”
readonlyidleTimeout:"actor-ts.persistence.journal.mssql.idle-timeout"='actor-ts.persistence.journal.mssql.idle-timeout'
persistence.journal.mssql.maxPoolSize
Section titled “persistence.journal.mssql.maxPoolSize”
readonlymaxPoolSize:"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.
persistence.journal.mssql.requestTimeout
Section titled “persistence.journal.mssql.requestTimeout”
readonlyrequestTimeout:"actor-ts.persistence.journal.mssql.request-timeout"='actor-ts.persistence.journal.mssql.request-timeout'
persistence.journal.mssql.root
Section titled “persistence.journal.mssql.root”
readonlyroot:"actor-ts.persistence.journal.mssql"='actor-ts.persistence.journal.mssql'
persistence.journal.mssql.tagsTable
Section titled “persistence.journal.mssql.tagsTable”
readonlytagsTable:"actor-ts.persistence.journal.mssql.tags-table"='actor-ts.persistence.journal.mssql.tags-table'
persistence.journal.mssql.url
Section titled “persistence.journal.mssql.url”
readonlyurl:"actor-ts.persistence.journal.mssql.url"='actor-ts.persistence.journal.mssql.url'
persistence.journal.plugin
Section titled “persistence.journal.plugin”
readonlyplugin:"actor-ts.persistence.journal.plugin"='actor-ts.persistence.journal.plugin'
persistence.journal.postgres
Section titled “persistence.journal.postgres”
readonlypostgres: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”
readonlyautoCreateTables:"actor-ts.persistence.journal.postgres.auto-create-tables"='actor-ts.persistence.journal.postgres.auto-create-tables'
persistence.journal.postgres.caFile
Section titled “persistence.journal.postgres.caFile”
readonlycaFile:"actor-ts.persistence.journal.postgres.ca-file"='actor-ts.persistence.journal.postgres.ca-file'
persistence.journal.postgres.connectTimeout
Section titled “persistence.journal.postgres.connectTimeout”
readonlyconnectTimeout:"actor-ts.persistence.journal.postgres.connect-timeout"='actor-ts.persistence.journal.postgres.connect-timeout'
persistence.journal.postgres.eventsTable
Section titled “persistence.journal.postgres.eventsTable”
readonlyeventsTable:"actor-ts.persistence.journal.postgres.events-table"='actor-ts.persistence.journal.postgres.events-table'
persistence.journal.postgres.idleTimeout
Section titled “persistence.journal.postgres.idleTimeout”
readonlyidleTimeout:"actor-ts.persistence.journal.postgres.idle-timeout"='actor-ts.persistence.journal.postgres.idle-timeout'
persistence.journal.postgres.maxPoolSize
Section titled “persistence.journal.postgres.maxPoolSize”
readonlymaxPoolSize:"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.
persistence.journal.postgres.root
Section titled “persistence.journal.postgres.root”
readonlyroot:"actor-ts.persistence.journal.postgres"='actor-ts.persistence.journal.postgres'
persistence.journal.postgres.tagsTable
Section titled “persistence.journal.postgres.tagsTable”
readonlytagsTable:"actor-ts.persistence.journal.postgres.tags-table"='actor-ts.persistence.journal.postgres.tags-table'
persistence.journal.postgres.url
Section titled “persistence.journal.postgres.url”
readonlyurl:"actor-ts.persistence.journal.postgres.url"='actor-ts.persistence.journal.postgres.url'
persistence.journal.sqlite
Section titled “persistence.journal.sqlite”
readonlysqlite: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).
persistence.journal.sqlite.busyTimeout
Section titled “persistence.journal.sqlite.busyTimeout”
readonlybusyTimeout:"actor-ts.persistence.journal.sqlite.busy-timeout"='actor-ts.persistence.journal.sqlite.busy-timeout'
persistence.journal.sqlite.eventsTable
Section titled “persistence.journal.sqlite.eventsTable”
readonlyeventsTable:"actor-ts.persistence.journal.sqlite.events-table"='actor-ts.persistence.journal.sqlite.events-table'
persistence.journal.sqlite.path
Section titled “persistence.journal.sqlite.path”
readonlypath:"actor-ts.persistence.journal.sqlite.path"='actor-ts.persistence.journal.sqlite.path'
persistence.journal.sqlite.root
Section titled “persistence.journal.sqlite.root”
readonlyroot:"actor-ts.persistence.journal.sqlite"='actor-ts.persistence.journal.sqlite'
persistence.journal.sqlite.wal
Section titled “persistence.journal.sqlite.wal”
readonlywal:"actor-ts.persistence.journal.sqlite.wal"='actor-ts.persistence.journal.sqlite.wal'
persistence.journalBreaker
Section titled “persistence.journalBreaker”
readonlyjournalBreaker:"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.
persistence.maxConcurrentRecoveries
Section titled “persistence.maxConcurrentRecoveries”
readonlymaxConcurrentRecoveries:"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.
persistence.recoveryTimeout
Section titled “persistence.recoveryTimeout”
readonlyrecoveryTimeout:"actor-ts.persistence.recovery-timeout"='actor-ts.persistence.recovery-timeout'
persistence.snapshotBreaker
Section titled “persistence.snapshotBreaker”
readonlysnapshotBreaker:"actor-ts.persistence.snapshot-breaker"='actor-ts.persistence.snapshot-breaker'
persistence.snapshotIsOptional
Section titled “persistence.snapshotIsOptional”
readonlysnapshotIsOptional:"actor-ts.persistence.snapshot-is-optional"='actor-ts.persistence.snapshot-is-optional'
persistence.snapshotStore
Section titled “persistence.snapshotStore”
readonlysnapshotStore:object
persistence.snapshotStore.cassandra
Section titled “persistence.snapshotStore.cassandra”
readonlycassandra:object
The Cassandra / ScyllaDB snapshot store’s block - see journal’s cassandra.
persistence.snapshotStore.cassandra.autoCreateKeyspace
Section titled “persistence.snapshotStore.cassandra.autoCreateKeyspace”
readonlyautoCreateKeyspace:"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”
readonlyautoCreateTables:"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”
readonlyconsistency:"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”
readonlycontactPoints:"actor-ts.persistence.snapshot-store.cassandra.contact-points"='actor-ts.persistence.snapshot-store.cassandra.contact-points'
persistence.snapshotStore.cassandra.keepN
Section titled “persistence.snapshotStore.cassandra.keepN”
readonlykeepN:"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”
readonlykeyspace:"actor-ts.persistence.snapshot-store.cassandra.keyspace"='actor-ts.persistence.snapshot-store.cassandra.keyspace'
persistence.snapshotStore.cassandra.localDataCenter
Section titled “persistence.snapshotStore.cassandra.localDataCenter”
readonlylocalDataCenter:"actor-ts.persistence.snapshot-store.cassandra.local-data-center"='actor-ts.persistence.snapshot-store.cassandra.local-data-center'
persistence.snapshotStore.cassandra.port
Section titled “persistence.snapshotStore.cassandra.port”
readonlyport:"actor-ts.persistence.snapshot-store.cassandra.port"='actor-ts.persistence.snapshot-store.cassandra.port'
persistence.snapshotStore.cassandra.replicationClass
Section titled “persistence.snapshotStore.cassandra.replicationClass”
readonlyreplicationClass:"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”
readonlyreplicationDataCenters:"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”
readonlyreplicationFactor:"actor-ts.persistence.snapshot-store.cassandra.replication.replication-factor"='actor-ts.persistence.snapshot-store.cassandra.replication.replication-factor'
persistence.snapshotStore.cassandra.root
Section titled “persistence.snapshotStore.cassandra.root”
readonlyroot:"actor-ts.persistence.snapshot-store.cassandra"='actor-ts.persistence.snapshot-store.cassandra'
persistence.snapshotStore.cassandra.snapshotsTable
Section titled “persistence.snapshotStore.cassandra.snapshotsTable”
readonlysnapshotsTable:"actor-ts.persistence.snapshot-store.cassandra.snapshots-table"='actor-ts.persistence.snapshot-store.cassandra.snapshots-table'
persistence.snapshotStore.cloudflareD1
Section titled “persistence.snapshotStore.cloudflareD1”
readonlycloudflareD1:object
The Cloudflare D1 snapshot store’s block — see postgres.
persistence.snapshotStore.cloudflareD1.accountId
Section titled “persistence.snapshotStore.cloudflareD1.accountId”
readonlyaccountId:"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”
readonlyapiToken:"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”
readonlyautoCreateTables:"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”
readonlybaseUrl:"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”
readonlydatabaseId:"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”
readonlykeepN:"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”
readonlymaxResponseBytes:"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”
readonlyroot:"actor-ts.persistence.snapshot-store.cloudflare-d1"='actor-ts.persistence.snapshot-store.cloudflare-d1'
persistence.snapshotStore.cloudflareD1.snapshotsTable
Section titled “persistence.snapshotStore.cloudflareD1.snapshotsTable”
readonlysnapshotsTable:"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”
readonlytimeout:"actor-ts.persistence.snapshot-store.cloudflare-d1.timeout"='actor-ts.persistence.snapshot-store.cloudflare-d1.timeout'
persistence.snapshotStore.dynamodb
Section titled “persistence.snapshotStore.dynamodb”
readonlydynamodb:object
The DynamoDB snapshot store’s block - see journal’s dynamodb.
persistence.snapshotStore.dynamodb.autoCreateTables
Section titled “persistence.snapshotStore.dynamodb.autoCreateTables”
readonlyautoCreateTables:"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”
readonlybillingMode:"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”
readonlyconnectionTimeout:"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”
readonlyendpoint:"actor-ts.persistence.snapshot-store.dynamodb.endpoint"='actor-ts.persistence.snapshot-store.dynamodb.endpoint'
persistence.snapshotStore.dynamodb.keepN
Section titled “persistence.snapshotStore.dynamodb.keepN”
readonlykeepN:"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”
readonlymaxAttempts:"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”
readonlyprovisionedThroughputReadCapacityUnits:"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”
readonlyprovisionedThroughputWriteCapacityUnits:"actor-ts.persistence.snapshot-store.dynamodb.provisioned-throughput.write-capacity-units"='actor-ts.persistence.snapshot-store.dynamodb.provisioned-throughput.write-capacity-units'
persistence.snapshotStore.dynamodb.region
Section titled “persistence.snapshotStore.dynamodb.region”
readonlyregion:"actor-ts.persistence.snapshot-store.dynamodb.region"='actor-ts.persistence.snapshot-store.dynamodb.region'
persistence.snapshotStore.dynamodb.requestTimeout
Section titled “persistence.snapshotStore.dynamodb.requestTimeout”
readonlyrequestTimeout:"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”
readonlyretryMode:"actor-ts.persistence.snapshot-store.dynamodb.retry-mode"='actor-ts.persistence.snapshot-store.dynamodb.retry-mode'
persistence.snapshotStore.dynamodb.root
Section titled “persistence.snapshotStore.dynamodb.root”
readonlyroot:"actor-ts.persistence.snapshot-store.dynamodb"='actor-ts.persistence.snapshot-store.dynamodb'
persistence.snapshotStore.dynamodb.snapshotsTable
Section titled “persistence.snapshotStore.dynamodb.snapshotsTable”
readonlysnapshotsTable:"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”
readonlytableReadyTimeout:"actor-ts.persistence.snapshot-store.dynamodb.table-ready-timeout"='actor-ts.persistence.snapshot-store.dynamodb.table-ready-timeout'
persistence.snapshotStore.inMemory
Section titled “persistence.snapshotStore.inMemory”
readonlyinMemory: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.
persistence.snapshotStore.inMemory.keepN
Section titled “persistence.snapshotStore.inMemory.keepN”
readonlykeepN:"actor-ts.persistence.snapshot-store.in-memory.keep-n"='actor-ts.persistence.snapshot-store.in-memory.keep-n'
persistence.snapshotStore.inMemory.root
Section titled “persistence.snapshotStore.inMemory.root”
readonlyroot:"actor-ts.persistence.snapshot-store.in-memory"='actor-ts.persistence.snapshot-store.in-memory'
persistence.snapshotStore.libsql
Section titled “persistence.snapshotStore.libsql”
readonlylibsql:object
The libSQL snapshot store’s block — see postgres.
persistence.snapshotStore.libsql.authToken
Section titled “persistence.snapshotStore.libsql.authToken”
readonlyauthToken:"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”
readonlyautoCreateTables:"actor-ts.persistence.snapshot-store.libsql.auto-create-tables"='actor-ts.persistence.snapshot-store.libsql.auto-create-tables'
persistence.snapshotStore.libsql.keepN
Section titled “persistence.snapshotStore.libsql.keepN”
readonlykeepN:"actor-ts.persistence.snapshot-store.libsql.keep-n"='actor-ts.persistence.snapshot-store.libsql.keep-n'
persistence.snapshotStore.libsql.root
Section titled “persistence.snapshotStore.libsql.root”
readonlyroot:"actor-ts.persistence.snapshot-store.libsql"='actor-ts.persistence.snapshot-store.libsql'
persistence.snapshotStore.libsql.snapshotsTable
Section titled “persistence.snapshotStore.libsql.snapshotsTable”
readonlysnapshotsTable:"actor-ts.persistence.snapshot-store.libsql.snapshots-table"='actor-ts.persistence.snapshot-store.libsql.snapshots-table'
persistence.snapshotStore.libsql.url
Section titled “persistence.snapshotStore.libsql.url”
readonlyurl:"actor-ts.persistence.snapshot-store.libsql.url"='actor-ts.persistence.snapshot-store.libsql.url'
persistence.snapshotStore.mariadb
Section titled “persistence.snapshotStore.mariadb”
readonlymariadb:object
The MariaDB snapshot store’s block — see postgres.
persistence.snapshotStore.mariadb.acquireTimeout
Section titled “persistence.snapshotStore.mariadb.acquireTimeout”
readonlyacquireTimeout:"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”
readonlyautoCreateTables:"actor-ts.persistence.snapshot-store.mariadb.auto-create-tables"='actor-ts.persistence.snapshot-store.mariadb.auto-create-tables'
persistence.snapshotStore.mariadb.caFile
Section titled “persistence.snapshotStore.mariadb.caFile”
readonlycaFile:"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”
readonlyconnectTimeout:"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”
readonlyidleTimeout:"actor-ts.persistence.snapshot-store.mariadb.idle-timeout"='actor-ts.persistence.snapshot-store.mariadb.idle-timeout'
persistence.snapshotStore.mariadb.keepN
Section titled “persistence.snapshotStore.mariadb.keepN”
readonlykeepN:"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”
readonlymaxPoolSize:"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.
persistence.snapshotStore.mariadb.root
Section titled “persistence.snapshotStore.mariadb.root”
readonlyroot:"actor-ts.persistence.snapshot-store.mariadb"='actor-ts.persistence.snapshot-store.mariadb'
persistence.snapshotStore.mariadb.snapshotsTable
Section titled “persistence.snapshotStore.mariadb.snapshotsTable”
readonlysnapshotsTable:"actor-ts.persistence.snapshot-store.mariadb.snapshots-table"='actor-ts.persistence.snapshot-store.mariadb.snapshots-table'
persistence.snapshotStore.mariadb.url
Section titled “persistence.snapshotStore.mariadb.url”
readonlyurl:"actor-ts.persistence.snapshot-store.mariadb.url"='actor-ts.persistence.snapshot-store.mariadb.url'
persistence.snapshotStore.mongodb
Section titled “persistence.snapshotStore.mongodb”
readonlymongodb:object
The MongoDB snapshot store’s block - see journal’s mongodb.
persistence.snapshotStore.mongodb.autoCreateIndexes
Section titled “persistence.snapshotStore.mongodb.autoCreateIndexes”
readonlyautoCreateIndexes:"actor-ts.persistence.snapshot-store.mongodb.auto-create-indexes"='actor-ts.persistence.snapshot-store.mongodb.auto-create-indexes'
persistence.snapshotStore.mongodb.caFile
Section titled “persistence.snapshotStore.mongodb.caFile”
readonlycaFile:"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”
readonlyconnectTimeout:"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”
readonlydatabaseName:"actor-ts.persistence.snapshot-store.mongodb.database-name"='actor-ts.persistence.snapshot-store.mongodb.database-name'
persistence.snapshotStore.mongodb.keepN
Section titled “persistence.snapshotStore.mongodb.keepN”
readonlykeepN:"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”
readonlymaxPoolSize:"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”
readonlyminPoolSize:"actor-ts.persistence.snapshot-store.mongodb.min-pool-size"='actor-ts.persistence.snapshot-store.mongodb.min-pool-size'
persistence.snapshotStore.mongodb.root
Section titled “persistence.snapshotStore.mongodb.root”
readonlyroot:"actor-ts.persistence.snapshot-store.mongodb"='actor-ts.persistence.snapshot-store.mongodb'
persistence.snapshotStore.mongodb.serverSelectionTimeout
Section titled “persistence.snapshotStore.mongodb.serverSelectionTimeout”
readonlyserverSelectionTimeout:"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”
readonlysnapshotsCollection:"actor-ts.persistence.snapshot-store.mongodb.snapshots-collection"='actor-ts.persistence.snapshot-store.mongodb.snapshots-collection'
persistence.snapshotStore.mongodb.url
Section titled “persistence.snapshotStore.mongodb.url”
readonlyurl:"actor-ts.persistence.snapshot-store.mongodb.url"='actor-ts.persistence.snapshot-store.mongodb.url'
persistence.snapshotStore.mssql
Section titled “persistence.snapshotStore.mssql”
readonlymssql:object
The SQL Server snapshot store’s block — see postgres.
persistence.snapshotStore.mssql.autoCreateTables
Section titled “persistence.snapshotStore.mssql.autoCreateTables”
readonlyautoCreateTables:"actor-ts.persistence.snapshot-store.mssql.auto-create-tables"='actor-ts.persistence.snapshot-store.mssql.auto-create-tables'
persistence.snapshotStore.mssql.caFile
Section titled “persistence.snapshotStore.mssql.caFile”
readonlycaFile:"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”
readonlyconnectTimeout:"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”
readonlyidleTimeout:"actor-ts.persistence.snapshot-store.mssql.idle-timeout"='actor-ts.persistence.snapshot-store.mssql.idle-timeout'
persistence.snapshotStore.mssql.keepN
Section titled “persistence.snapshotStore.mssql.keepN”
readonlykeepN:"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”
readonlymaxPoolSize:"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”
readonlyrequestTimeout:"actor-ts.persistence.snapshot-store.mssql.request-timeout"='actor-ts.persistence.snapshot-store.mssql.request-timeout'
persistence.snapshotStore.mssql.root
Section titled “persistence.snapshotStore.mssql.root”
readonlyroot:"actor-ts.persistence.snapshot-store.mssql"='actor-ts.persistence.snapshot-store.mssql'
persistence.snapshotStore.mssql.snapshotsTable
Section titled “persistence.snapshotStore.mssql.snapshotsTable”
readonlysnapshotsTable:"actor-ts.persistence.snapshot-store.mssql.snapshots-table"='actor-ts.persistence.snapshot-store.mssql.snapshots-table'
persistence.snapshotStore.mssql.url
Section titled “persistence.snapshotStore.mssql.url”
readonlyurl:"actor-ts.persistence.snapshot-store.mssql.url"='actor-ts.persistence.snapshot-store.mssql.url'
persistence.snapshotStore.objectStorage
Section titled “persistence.snapshotStore.objectStorage”
readonlyobjectStorage: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”
readonlybackend:"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”
readonlycompressionAlgorithm:"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”
readonlycompressionLevel:"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”
readonlyencryptionKmsKeyId:"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”
readonlyencryptionMode:"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”
readonlyfilesystemDir:"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”
readonlyfilesystemLockTimeout:"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”
readonlyfilesystemStaleLock:"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”
readonlykeepN:"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”
readonlymaxDecompressedBytes:"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”
readonlyprefix:"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”
readonlyroot:"actor-ts.persistence.snapshot-store.object-storage"='actor-ts.persistence.snapshot-store.object-storage'
persistence.snapshotStore.objectStorage.s3Bucket
Section titled “persistence.snapshotStore.objectStorage.s3Bucket”
readonlys3Bucket:"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”
readonlys3Endpoint:"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”
readonlys3ForcePathStyle:"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”
readonlys3Region:"actor-ts.persistence.snapshot-store.object-storage.s3.region"='actor-ts.persistence.snapshot-store.object-storage.s3.region'
persistence.snapshotStore.plugin
Section titled “persistence.snapshotStore.plugin”
readonlyplugin:"actor-ts.persistence.snapshot-store.plugin"='actor-ts.persistence.snapshot-store.plugin'
persistence.snapshotStore.postgres
Section titled “persistence.snapshotStore.postgres”
readonlypostgres: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”
readonlyautoCreateTables:"actor-ts.persistence.snapshot-store.postgres.auto-create-tables"='actor-ts.persistence.snapshot-store.postgres.auto-create-tables'
persistence.snapshotStore.postgres.caFile
Section titled “persistence.snapshotStore.postgres.caFile”
readonlycaFile:"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”
readonlyconnectTimeout:"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”
readonlyidleTimeout:"actor-ts.persistence.snapshot-store.postgres.idle-timeout"='actor-ts.persistence.snapshot-store.postgres.idle-timeout'
persistence.snapshotStore.postgres.keepN
Section titled “persistence.snapshotStore.postgres.keepN”
readonlykeepN:"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”
readonlymaxPoolSize:"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.
persistence.snapshotStore.postgres.root
Section titled “persistence.snapshotStore.postgres.root”
readonlyroot:"actor-ts.persistence.snapshot-store.postgres"='actor-ts.persistence.snapshot-store.postgres'
persistence.snapshotStore.postgres.snapshotsTable
Section titled “persistence.snapshotStore.postgres.snapshotsTable”
readonlysnapshotsTable:"actor-ts.persistence.snapshot-store.postgres.snapshots-table"='actor-ts.persistence.snapshot-store.postgres.snapshots-table'
persistence.snapshotStore.postgres.url
Section titled “persistence.snapshotStore.postgres.url”
readonlyurl:"actor-ts.persistence.snapshot-store.postgres.url"='actor-ts.persistence.snapshot-store.postgres.url'
persistence.snapshotStore.sqlite
Section titled “persistence.snapshotStore.sqlite”
readonlysqlite:object
The SQLite snapshot store’s block — see journal’s sqlite.
persistence.snapshotStore.sqlite.busyTimeout
Section titled “persistence.snapshotStore.sqlite.busyTimeout”
readonlybusyTimeout:"actor-ts.persistence.snapshot-store.sqlite.busy-timeout"='actor-ts.persistence.snapshot-store.sqlite.busy-timeout'
persistence.snapshotStore.sqlite.keepN
Section titled “persistence.snapshotStore.sqlite.keepN”
readonlykeepN:"actor-ts.persistence.snapshot-store.sqlite.keep-n"='actor-ts.persistence.snapshot-store.sqlite.keep-n'
persistence.snapshotStore.sqlite.path
Section titled “persistence.snapshotStore.sqlite.path”
readonlypath:"actor-ts.persistence.snapshot-store.sqlite.path"='actor-ts.persistence.snapshot-store.sqlite.path'
persistence.snapshotStore.sqlite.root
Section titled “persistence.snapshotStore.sqlite.root”
readonlyroot:"actor-ts.persistence.snapshot-store.sqlite"='actor-ts.persistence.snapshot-store.sqlite'
persistence.snapshotStore.sqlite.snapshotsTable
Section titled “persistence.snapshotStore.sqlite.snapshotsTable”
readonlysnapshotsTable:"actor-ts.persistence.snapshot-store.sqlite.snapshots-table"='actor-ts.persistence.snapshot-store.sqlite.snapshots-table'
projection
Section titled “projection”
readonlyprojection: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).
projection.groupAfterEnvelopes
Section titled “projection.groupAfterEnvelopes”
readonlygroupAfterEnvelopes:"actor-ts.projection.group-after-envelopes"='actor-ts.projection.group-after-envelopes'
projection.maxRetries
Section titled “projection.maxRetries”
readonlymaxRetries:"actor-ts.projection.max-retries"='actor-ts.projection.max-retries'
projection.maxRetryBackoff
Section titled “projection.maxRetryBackoff”
readonlymaxRetryBackoff:"actor-ts.projection.max-retry-backoff"='actor-ts.projection.max-retry-backoff'
projection.pollInterval
Section titled “projection.pollInterval”
readonlypollInterval:"actor-ts.projection.poll-interval"='actor-ts.projection.poll-interval'
projection.recoveryStrategy
Section titled “projection.recoveryStrategy”
readonlyrecoveryStrategy:"actor-ts.projection.recovery-strategy"='actor-ts.projection.recovery-strategy'
projection.retryBackoff
Section titled “projection.retryBackoff”
readonlyretryBackoff:"actor-ts.projection.retry-backoff"='actor-ts.projection.retry-backoff'
reliableDelivery
Section titled “reliableDelivery”
readonlyreliableDelivery: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.
reliableDelivery.consumer
Section titled “reliableDelivery.consumer”
readonlyconsumer:object
reliableDelivery.consumer.maxOutOfOrder
Section titled “reliableDelivery.consumer.maxOutOfOrder”
readonlymaxOutOfOrder:"actor-ts.reliable-delivery.consumer.max-out-of-order"='actor-ts.reliable-delivery.consumer.max-out-of-order'
reliableDelivery.consumer.maxProducers
Section titled “reliableDelivery.consumer.maxProducers”
readonlymaxProducers:"actor-ts.reliable-delivery.consumer.max-producers"='actor-ts.reliable-delivery.consumer.max-producers'
reliableDelivery.consumer.producerIdleTimeToLive
Section titled “reliableDelivery.consumer.producerIdleTimeToLive”
readonlyproducerIdleTimeToLive:"actor-ts.reliable-delivery.consumer.producer-idle-time-to-live"='actor-ts.reliable-delivery.consumer.producer-idle-time-to-live'
reliableDelivery.producer
Section titled “reliableDelivery.producer”
readonlyproducer:object
reliableDelivery.producer.resendTimeout
Section titled “reliableDelivery.producer.resendTimeout”
readonlyresendTimeout:"actor-ts.reliable-delivery.producer.resend-timeout"='actor-ts.reliable-delivery.producer.resend-timeout'
reliableDelivery.producer.windowSize
Section titled “reliableDelivery.producer.windowSize”
readonlywindowSize:"actor-ts.reliable-delivery.producer.window-size"='actor-ts.reliable-delivery.producer.window-size'
remote
Section titled “remote”
readonlyremote: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.
remote.connectTimeout
Section titled “remote.connectTimeout”
readonlyconnectTimeout:"actor-ts.remote.connect-timeout"='actor-ts.remote.connect-timeout'
remote.handshakeTimeout
Section titled “remote.handshakeTimeout”
readonlyhandshakeTimeout:"actor-ts.remote.handshake-timeout"='actor-ts.remote.handshake-timeout'
remote.incompleteFrameIdle
Section titled “remote.incompleteFrameIdle”
readonlyincompleteFrameIdle:"actor-ts.remote.incomplete-frame-idle"='actor-ts.remote.incomplete-frame-idle'
remote.maxFrameBytes
Section titled “remote.maxFrameBytes”
readonlymaxFrameBytes:"actor-ts.remote.max-frame-bytes"='actor-ts.remote.max-frame-bytes'
remote.maxInboundConnections
Section titled “remote.maxInboundConnections”
readonlymaxInboundConnections:"actor-ts.remote.max-inbound-connections"='actor-ts.remote.max-inbound-connections'
remote.outboundQueueSize
Section titled “remote.outboundQueueSize”
readonlyoutboundQueueSize:"actor-ts.remote.outbound-queue-size"='actor-ts.remote.outbound-queue-size'
remote.tcp
Section titled “remote.tcp”
readonlytcp:object
remote.tcp.advertisedHost
Section titled “remote.tcp.advertisedHost”
readonlyadvertisedHost:"actor-ts.remote.tcp.advertised-host"='actor-ts.remote.tcp.advertised-host'
remote.tcp.advertisedPort
Section titled “remote.tcp.advertisedPort”
readonlyadvertisedPort:"actor-ts.remote.tcp.advertised-port"='actor-ts.remote.tcp.advertised-port'
remote.tcp.host
Section titled “remote.tcp.host”
readonlyhost:"actor-ts.remote.tcp.host"='actor-ts.remote.tcp.host'
remote.tcp.port
Section titled “remote.tcp.port”
readonlyport:"actor-ts.remote.tcp.port"='actor-ts.remote.tcp.port'
remote.tls
Section titled “remote.tls”
readonlytls:object
remote.tls.enabled
Section titled “remote.tls.enabled”
readonlyenabled:"actor-ts.remote.tls.enabled"='actor-ts.remote.tls.enabled'
remote.trustedSelectionPaths
Section titled “remote.trustedSelectionPaths”
readonlytrustedSelectionPaths:"actor-ts.remote.trusted-selection-paths"='actor-ts.remote.trusted-selection-paths'
remote.untrustedMode
Section titled “remote.untrustedMode”
readonlyuntrustedMode:"actor-ts.remote.untrusted-mode"='actor-ts.remote.untrusted-mode'
serialization
Section titled “serialization”
readonlyserialization: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.
serialization.readConstraints
Section titled “serialization.readConstraints”
readonlyreadConstraints:object
serialization.readConstraints.maxDocumentBytes
Section titled “serialization.readConstraints.maxDocumentBytes”
readonlymaxDocumentBytes:"actor-ts.serialization.read-constraints.max-document-bytes"='actor-ts.serialization.read-constraints.max-document-bytes'
serialization.readConstraints.maxNestingDepth
Section titled “serialization.readConstraints.maxNestingDepth”
readonlymaxNestingDepth:"actor-ts.serialization.read-constraints.max-nesting-depth"='actor-ts.serialization.read-constraints.max-nesting-depth'
serialization.readConstraints.maxStringLength
Section titled “serialization.readConstraints.maxStringLength”
readonlymaxStringLength:"actor-ts.serialization.read-constraints.max-string-length"='actor-ts.serialization.read-constraints.max-string-length'
shardedDaemonProcess
Section titled “shardedDaemonProcess”
readonlyshardedDaemonProcess: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.
shardedDaemonProcess.livenessInterval
Section titled “shardedDaemonProcess.livenessInterval”
readonlylivenessInterval:"actor-ts.sharded-daemon-process.liveness-interval"='actor-ts.sharded-daemon-process.liveness-interval'
shardedDaemonProcess.role
Section titled “shardedDaemonProcess.role”
readonlyrole:"actor-ts.sharded-daemon-process.role"='actor-ts.sharded-daemon-process.role'
sharding
Section titled “sharding”
readonlysharding: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.
sharding.acquireRetryInterval
Section titled “sharding.acquireRetryInterval”
readonlyacquireRetryInterval:"actor-ts.sharding.acquire-retry-interval"='actor-ts.sharding.acquire-retry-interval'
sharding.bufferSize
Section titled “sharding.bufferSize”
readonlybufferSize:"actor-ts.sharding.buffer-size"='actor-ts.sharding.buffer-size'
sharding.coordinatorStateLoadTimeout
Section titled “sharding.coordinatorStateLoadTimeout”
readonlycoordinatorStateLoadTimeout:"actor-ts.sharding.coordinator-state-load-timeout"='actor-ts.sharding.coordinator-state-load-timeout'
sharding.entityRecoveryConstantRateFrequency
Section titled “sharding.entityRecoveryConstantRateFrequency”
readonlyentityRecoveryConstantRateFrequency:"actor-ts.sharding.entity-recovery.constant-rate.frequency"='actor-ts.sharding.entity-recovery.constant-rate.frequency'
sharding.entityRecoveryConstantRateNumberOfEntities
Section titled “sharding.entityRecoveryConstantRateNumberOfEntities”
readonlyentityRecoveryConstantRateNumberOfEntities:"actor-ts.sharding.entity-recovery.constant-rate.number-of-entities"='actor-ts.sharding.entity-recovery.constant-rate.number-of-entities'
sharding.entityRecoveryStrategy
Section titled “sharding.entityRecoveryStrategy”
readonlyentityRecoveryStrategy:"actor-ts.sharding.entity-recovery.strategy"='actor-ts.sharding.entity-recovery.strategy'
sharding.entityRestartBackoff
Section titled “sharding.entityRestartBackoff”
readonlyentityRestartBackoff: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.
sharding.entityRestartBackoff.max
Section titled “sharding.entityRestartBackoff.max”
readonlymax:"actor-ts.sharding.entity-restart-backoff.max"='actor-ts.sharding.entity-restart-backoff.max'
sharding.entityRestartBackoff.min
Section titled “sharding.entityRestartBackoff.min”
readonlymin:"actor-ts.sharding.entity-restart-backoff.min"='actor-ts.sharding.entity-restart-backoff.min'
sharding.entityRestartBackoff.randomFactor
Section titled “sharding.entityRestartBackoff.randomFactor”
readonlyrandomFactor:"actor-ts.sharding.entity-restart-backoff.random-factor"='actor-ts.sharding.entity-restart-backoff.random-factor'
sharding.entityRestartBackoff.resetAfter
Section titled “sharding.entityRestartBackoff.resetAfter”
readonlyresetAfter:"actor-ts.sharding.entity-restart-backoff.reset-after"='actor-ts.sharding.entity-restart-backoff.reset-after'
sharding.handOffTimeout
Section titled “sharding.handOffTimeout”
readonlyhandOffTimeout:"actor-ts.sharding.hand-off-timeout"='actor-ts.sharding.hand-off-timeout'
sharding.healthcheck
Section titled “sharding.healthcheck”
readonlyhealthcheck: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.
sharding.healthcheck.names
Section titled “sharding.healthcheck.names”
readonlynames:"actor-ts.sharding.healthcheck.names"='actor-ts.sharding.healthcheck.names'
sharding.maxEntities
Section titled “sharding.maxEntities”
readonlymaxEntities:"actor-ts.sharding.max-entities"='actor-ts.sharding.max-entities'
sharding.numberOfShards
Section titled “sharding.numberOfShards”
readonlynumberOfShards:"actor-ts.sharding.number-of-shards"='actor-ts.sharding.number-of-shards'
sharding.passivationAdmissionFilter
Section titled “sharding.passivationAdmissionFilter”
readonlypassivationAdmissionFilter:"actor-ts.sharding.passivation.admission-filter"='actor-ts.sharding.passivation.admission-filter'
sharding.passivationAdmissionWindowProportion
Section titled “sharding.passivationAdmissionWindowProportion”
readonlypassivationAdmissionWindowProportion:"actor-ts.sharding.passivation.admission-window-proportion"='actor-ts.sharding.passivation.admission-window-proportion'
sharding.passivationIdle
Section titled “sharding.passivationIdle”
readonlypassivationIdle:"actor-ts.sharding.passivation-idle"='actor-ts.sharding.passivation-idle'
sharding.passivationReplacement
Section titled “sharding.passivationReplacement”
readonlypassivationReplacement:"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”
readonlypassivationSegmentedProtectedProportion:"actor-ts.sharding.passivation.segmented-protected-proportion"='actor-ts.sharding.passivation.segmented-protected-proportion'
sharding.passivationStopTimeout
Section titled “sharding.passivationStopTimeout”
readonlypassivationStopTimeout:"actor-ts.sharding.passivation.stop-timeout"='actor-ts.sharding.passivation.stop-timeout'
sharding.persistCoordinatorState
Section titled “sharding.persistCoordinatorState”
readonlypersistCoordinatorState:"actor-ts.sharding.persist-coordinator-state"='actor-ts.sharding.persist-coordinator-state'
sharding.rebalanceAbsoluteLimit
Section titled “sharding.rebalanceAbsoluteLimit”
readonlyrebalanceAbsoluteLimit:"actor-ts.sharding.rebalance-absolute-limit"='actor-ts.sharding.rebalance-absolute-limit'
sharding.rebalanceInterval
Section titled “sharding.rebalanceInterval”
readonlyrebalanceInterval:"actor-ts.sharding.rebalance-interval"='actor-ts.sharding.rebalance-interval'
sharding.rebalanceRelativeLimit
Section titled “sharding.rebalanceRelativeLimit”
readonlyrebalanceRelativeLimit:"actor-ts.sharding.rebalance-relative-limit"='actor-ts.sharding.rebalance-relative-limit'
sharding.registerRetryInterval
Section titled “sharding.registerRetryInterval”
readonlyregisterRetryInterval:"actor-ts.sharding.register-retry-interval"='actor-ts.sharding.register-retry-interval'
sharding.rememberEntities
Section titled “sharding.rememberEntities”
readonlyrememberEntities:"actor-ts.sharding.remember-entities"='actor-ts.sharding.remember-entities'
sharding.role
Section titled “sharding.role”
readonlyrole:"actor-ts.sharding.role"='actor-ts.sharding.role'
sharding.shardFailureBackoff
Section titled “sharding.shardFailureBackoff”
readonlyshardFailureBackoff: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.
sharding.shardFailureBackoff.max
Section titled “sharding.shardFailureBackoff.max”
readonlymax:"actor-ts.sharding.shard-failure-backoff.max"='actor-ts.sharding.shard-failure-backoff.max'
sharding.shardFailureBackoff.min
Section titled “sharding.shardFailureBackoff.min”
readonlymin:"actor-ts.sharding.shard-failure-backoff.min"='actor-ts.sharding.shard-failure-backoff.min'
sharding.shardFailureBackoff.randomFactor
Section titled “sharding.shardFailureBackoff.randomFactor”
readonlyrandomFactor:"actor-ts.sharding.shard-failure-backoff.random-factor"='actor-ts.sharding.shard-failure-backoff.random-factor'
sharding.shardFailureBackoff.resetAfter
Section titled “sharding.shardFailureBackoff.resetAfter”
readonlyresetAfter:"actor-ts.sharding.shard-failure-backoff.reset-after"='actor-ts.sharding.shard-failure-backoff.reset-after'
sharding.shardPassivationIdle
Section titled “sharding.shardPassivationIdle”
readonlyshardPassivationIdle:"actor-ts.sharding.shard-passivation-idle"='actor-ts.sharding.shard-passivation-idle'
sharding.shardRegionQueryTimeout
Section titled “sharding.shardRegionQueryTimeout”
readonlyshardRegionQueryTimeout:"actor-ts.sharding.shard-region-query-timeout"='actor-ts.sharding.shard-region-query-timeout'
sharding.staleRegionDetection
Section titled “sharding.staleRegionDetection”
readonlystaleRegionDetection: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.
sharding.staleRegionDetection.enabled
Section titled “sharding.staleRegionDetection.enabled”
readonlyenabled:"actor-ts.sharding.stale-region-detection.enabled"='actor-ts.sharding.stale-region-detection.enabled'
sharding.staleRegionDetection.heartbeatInterval
Section titled “sharding.staleRegionDetection.heartbeatInterval”
readonlyheartbeatInterval:"actor-ts.sharding.stale-region-detection.heartbeat-interval"='actor-ts.sharding.stale-region-detection.heartbeat-interval'
sharding.staleRegionDetection.staleAfter
Section titled “sharding.staleRegionDetection.staleAfter”
readonlystaleAfter:"actor-ts.sharding.stale-region-detection.stale-after"='actor-ts.sharding.stale-region-detection.stale-after'
sharding.useLease
Section titled “sharding.useLease”
readonlyuseLease:"actor-ts.sharding.use-lease"='actor-ts.sharding.use-lease'
system
Section titled “system”
readonlysystem:object
ActorSystem identity and lifecycle — actor-ts.system.*.
system.name
Section titled “system.name”
readonlyname:"actor-ts.system.name"='actor-ts.system.name'
system.shutdownDrainTimeout
Section titled “system.shutdownDrainTimeout”
readonlyshutdownDrainTimeout:"actor-ts.system.shutdown-drain-timeout"='actor-ts.system.shutdown-drain-timeout'
tracing
Section titled “tracing”
readonlytracing: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.
tracing.loggerName
Section titled “tracing.loggerName”
readonlyloggerName:"actor-ts.tracing.logger-name"='actor-ts.tracing.logger-name'
tracing.loggerVersion
Section titled “tracing.loggerVersion”
readonlyloggerVersion:"actor-ts.tracing.logger-version"='actor-ts.tracing.logger-version'
Comment-only in reference.conf — unset passes no version to getLogger.
tracing.tracerName
Section titled “tracing.tracerName”
readonlytracerName:"actor-ts.tracing.tracer-name"='actor-ts.tracing.tracer-name'
tracing.tracerVersion
Section titled “tracing.tracerVersion”
readonlytracerVersion:"actor-ts.tracing.tracer-version"='actor-ts.tracing.tracer-version'
Comment-only in reference.conf — unset passes no version to getTracer.
worker
Section titled “worker”
readonlyworker: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.
worker.hello
Section titled “worker.hello”
readonlyhello:"worker-hello"='worker-hello'
worker.init
Section titled “worker.init”
readonlyinit:"worker-init"='worker-init'
worker.ready
Section titled “worker.ready”
readonlyready:"worker-ready"='worker-ready'
worker.transport
Section titled “worker.transport”
readonlytransport:"worker-transport"='worker-transport'
workerCluster
Section titled “workerCluster”
readonlyworkerCluster: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.
workerCluster.basePort
Section titled “workerCluster.basePort”
readonlybasePort:"actor-ts.worker-cluster.base-port"='actor-ts.worker-cluster.base-port'
workerCluster.hostname
Section titled “workerCluster.hostname”
readonlyhostname:"actor-ts.worker-cluster.hostname"='actor-ts.worker-cluster.hostname'
workerCluster.maxRestarts
Section titled “workerCluster.maxRestarts”
readonlymaxRestarts:"actor-ts.worker-cluster.max-restarts"='actor-ts.worker-cluster.max-restarts'
workerCluster.readyTimeout
Section titled “workerCluster.readyTimeout”
readonlyreadyTimeout:"actor-ts.worker-cluster.ready-timeout"='actor-ts.worker-cluster.ready-timeout'
workerCluster.restartMaxBackoff
Section titled “workerCluster.restartMaxBackoff”
readonlyrestartMaxBackoff:"actor-ts.worker-cluster.restart-max-backoff"='actor-ts.worker-cluster.restart-max-backoff'
workerCluster.restartMinBackoff
Section titled “workerCluster.restartMinBackoff”
readonlyrestartMinBackoff:"actor-ts.worker-cluster.restart-min-backoff"='actor-ts.worker-cluster.restart-min-backoff'
workerCluster.restartPolicy
Section titled “workerCluster.restartPolicy”
readonlyrestartPolicy:"actor-ts.worker-cluster.restart-policy"='actor-ts.worker-cluster.restart-policy'
workerCluster.restartRandomFactor
Section titled “workerCluster.restartRandomFactor”
readonlyrestartRandomFactor:"actor-ts.worker-cluster.restart-random-factor"='actor-ts.worker-cluster.restart-random-factor'
workerCluster.restartWindow
Section titled “workerCluster.restartWindow”
readonlyrestartWindow:"actor-ts.worker-cluster.restart-window"='actor-ts.worker-cluster.restart-window'
workerCluster.systemName
Section titled “workerCluster.systemName”
readonlysystemName:"actor-ts.worker-cluster.system-name"='actor-ts.worker-cluster.system-name'
workerCluster.workers
Section titled “workerCluster.workers”
readonlyworkers:"actor-ts.worker-cluster.workers"='actor-ts.worker-cluster.workers'
workerMesh
Section titled “workerMesh”
readonlyworkerMesh: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.
workerMesh.basePort
Section titled “workerMesh.basePort”
readonlybasePort:"actor-ts.worker-mesh.base-port"='actor-ts.worker-mesh.base-port'
workerMesh.mainHostname
Section titled “workerMesh.mainHostname”
readonlymainHostname:"actor-ts.worker-mesh.main-hostname"='actor-ts.worker-mesh.main-hostname'
workerMesh.mainPort
Section titled “workerMesh.mainPort”
readonlymainPort:"actor-ts.worker-mesh.main-port"='actor-ts.worker-mesh.main-port'
workerMesh.mainRoles
Section titled “workerMesh.mainRoles”
readonlymainRoles:"actor-ts.worker-mesh.main-roles"='actor-ts.worker-mesh.main-roles'
workerMesh.metricsRelayInterval
Section titled “workerMesh.metricsRelayInterval”
readonlymetricsRelayInterval:"actor-ts.worker-mesh.metrics-relay-interval"='actor-ts.worker-mesh.metrics-relay-interval'
workerMesh.workerHostname
Section titled “workerMesh.workerHostname”
readonlyworkerHostname:"actor-ts.worker-mesh.worker-hostname"='actor-ts.worker-mesh.worker-hostname'
workerMesh.workerRoles
Section titled “workerMesh.workerRoles”
readonlyworkerRoles:"actor-ts.worker-mesh.worker-roles"='actor-ts.worker-mesh.worker-roles'
workerMesh.workers
Section titled “workerMesh.workers”
readonlyworkers:"actor-ts.worker-mesh.workers"='actor-ts.worker-mesh.workers'
