@forgezero/runtime 0.1.8 → 0.1.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/README.md +1472 -240
  2. package/dist/audit.d.ts +21 -5
  3. package/dist/audit.js +32 -8
  4. package/dist/jobs.d.ts +7 -0
  5. package/dist/jobs.js +56 -2
  6. package/package.json +2 -2
package/README.md CHANGED
@@ -35,50 +35,50 @@ Every row links to the detailed explanation and named-import/example area below.
35
35
 
36
36
  | public entry | short description | runtime | details |
37
37
  |---|---|---|---|
38
- | @forgezero/runtime/query | Provider-neutral typed function contracts: decode untrusted input, run with caller-supplied services or storage, and strictly validate the result without coupling business logic to ForgeZero or ArangoDB. | portable | [Details + example](#forgezero-runtime-query) |
39
- | @forgezero/runtime/jobs | Background work that never overlaps itself, advances a cursor only on success, and can be paused and inspected. | portable | [Details + example](#forgezero-runtime-jobs) |
40
- | @forgezero/runtime/queue | Memory-only keyed work queue — awaited results, parallel across keys and strictly sequential within one; clustered callers atomically claim ownership in their own business store before submitting. | portable | [Details + example](#forgezero-runtime-queue) |
41
- | @forgezero/runtime/outbox | Write the event with the record, deliver it after, in order per key with backoff and a dead-letter queue. | portable | [Details + example](#forgezero-runtime-outbox) |
42
- | @forgezero/runtime/audit | Append-only records chained by hash, with a verifier that names the first altered entry. | portable | [Details + example](#forgezero-runtime-audit) |
43
- | @forgezero/runtime/backup | Encrypted, chunked, verified snapshots to object storage — and the restore that reads them back. | portable | [Details + example](#forgezero-runtime-backup) |
44
- | @forgezero/runtime/notify | Render a named template to text and HTML, escaped per part, refusing to send with a blank where a value should be. | portable | [Details + example](#forgezero-runtime-notify) |
45
- | @forgezero/runtime/notify/templates | The six transactional messages ForgeZero sends. | portable | [Details + example](#forgezero-runtime-notify-templates) |
46
- | @forgezero/runtime/calendar | Billing periods computed from an anchor, working days, holidays and due dates. | portable | [Details + example](#forgezero-runtime-calendar) |
47
- | @forgezero/runtime/compliance | Screening as a decision record — tiers, rules and lists, failing closed when a list is unreachable. | portable | [Details + example](#forgezero-runtime-compliance) |
48
- | @forgezero/runtime/totp | RFC 6238 TOTP on the existing HMAC — base32, an asymmetric window, and replay left to the caller. | portable | [Details + example](#forgezero-runtime-totp) |
49
- | @forgezero/runtime/passkey | Passkeys for sites that are not us. A vault-held credential is as unphishable as one in a security chip provided the RP ID check never slips — `evil-example.com` ends with `example.com` and is a different site. | portable | [Details + example](#forgezero-runtime-passkey) |
50
- | @forgezero/runtime/phrase | BIP-39 recovery phrases, and the salted verifier that proves one without being able to reconstruct it. | portable | [Details + example](#forgezero-runtime-phrase) |
51
- | @forgezero/runtime/snp | Parse an AMD SEV-SNP attestation report at the firmware ABI offsets, and compare a TCB component by component so a microcode bump cannot mask a firmware downgrade. | portable | [Details + example](#forgezero-runtime-snp) |
52
- | @forgezero/runtime/importers | Read secrets out of a .env, a CSV, or a Bitwarden or 1Password export — skipping what cannot be understood rather than guessing, and never putting a value in an error. | portable | [Details + example](#forgezero-runtime-importers) |
53
- | @forgezero/runtime/openssh | OpenSSH wire encoding, so a derived ed25519 key becomes a line that pastes into authorized_keys. | portable | [Details + example](#forgezero-runtime-openssh) |
54
- | @forgezero/runtime/ssh-cert | OpenSSH certificates, so access expires instead of having to be hunted down. Takes a signing FUNCTION rather than a secret key, which is what lets the CA live in a vault that never hands it out. | portable | [Details + example](#forgezero-runtime-ssh-cert) |
55
- | @forgezero/runtime/slip10 | SLIP-0010 derivation for ed25519, hardened-only — BIP-32 does not work on this curve and produces halves that do not correspond. | portable | [Details + example](#forgezero-runtime-slip10) |
56
- | @forgezero/runtime/identity | Hybrid Ed25519 + ML-DSA-65 request signing. One canonical string, so the compute agent that signs inside a guest and the API that verifies cannot drift — which two implementations of it certainly would. | portable | [Details + example](#forgezero-runtime-identity) |
57
- | @forgezero/runtime/schema | Validate against JSON Schema, restrict what a caller may declare, and describe a schema as a form. | portable | [Details + example](#forgezero-runtime-schema) |
58
- | @forgezero/runtime/schema/typebox | The TypeBox validator behind that interface. | portable | [Details + example](#forgezero-runtime-schema-typebox) |
59
- | @forgezero/runtime/finance/discounts | Promotions as arithmetic over integer minor units. They never stack — one winner — and a percentage rounds down, because rounding a discount up gives away a unit of currency per invoice forever. | portable | [Details + example](#forgezero-runtime-finance-discounts) |
60
- | @forgezero/runtime/finance/money | Exact amounts in minor units with the asset attached, so two currencies cannot be added. | portable | [Details + example](#forgezero-runtime-finance-money) |
61
- | @forgezero/runtime/finance/venues | Trading venues, market types and symbols as data — spot, margin and futures behind one order model. | portable | [Details + example](#forgezero-runtime-finance-venues) |
62
- | @forgezero/runtime/finance/ledger | Double-entry postings and derived balances. A hold is a posting, not a lock — the queue does the ordering. | portable | [Details + example](#forgezero-runtime-finance-ledger) |
63
- | @forgezero/runtime/finance/commission | Profit net of flows, a high-water mark, the tier split and the referral share of our income. | portable | [Details + example](#forgezero-runtime-finance-commission) |
64
- | @forgezero/runtime/finance/rates | What an asset is worth in USD, and how old that answer is. A peg never ages; a quote always does. | portable | [Details + example](#forgezero-runtime-finance-rates) |
65
- | @forgezero/runtime/finance/transfers | Deposits and withdrawals as ordered pipelines, with screening reserved at position zero. | portable | [Details + example](#forgezero-runtime-finance-transfers) |
66
- | @forgezero/runtime/finance/chain | Which chains exist, their confirmation depth by value band, assets and explorers — as data an admin edits. | portable | [Details + example](#forgezero-runtime-finance-chain) |
67
- | @forgezero/runtime/finance/custody | Derive CREATE2 deposit addresses and EIP-712 custody digests — arithmetic over a seed and a salt, needing no credential and no node. | portable | [Details + example](#forgezero-runtime-finance-custody) |
68
- | @forgezero/runtime/finance/derive | Declare a field ForgeZero generates rather than the tenant supplying: BIP-44 path arithmetic, and the choice of who is capable of generating the key. | portable | [Details + example](#forgezero-runtime-finance-derive) |
69
- | @forgezero/runtime/finance/tax | Which jurisdiction may tax a sale, who accounts for it, and the three ways to be zero that report differently. Rates are data. | portable | [Details + example](#forgezero-runtime-finance-tax) |
70
- | @forgezero/runtime/finance/storage | Write an amount so it is both exact and sortable: an authoritative string, and a number that is only an index. | portable | [Details + example](#forgezero-runtime-finance-storage) |
71
- | @forgezero/runtime/realtime | Provider-neutral realtime audience, shard, event and delivery contracts. | portable | [Details + example](#forgezero-runtime-realtime) |
72
- | @forgezero/runtime/passkey-hybrid | Versioned WebAuthn PRF plus ML-DSA companion proof construction and verification. | portable | [Details + example](#forgezero-runtime-passkey-hybrid) |
73
- | @forgezero/runtime/otpauth | Parse and render otpauth URIs without binding enrolment to a UI framework. | portable | [Details + example](#forgezero-runtime-otpauth) |
74
- | @forgezero/runtime/pipeline | Typed ordered application-pipeline execution with explicit evidence. | portable | [Details + example](#forgezero-runtime-pipeline) |
75
- | @forgezero/runtime/finance/chain-addresses | Chain-address derivation records and validation independent of a node provider. | portable | [Details + example](#forgezero-runtime-finance-chain-addresses) |
76
- | @forgezero/runtime/finance/chain-deposits | Provider-neutral deposit observation, confirmation and credit transitions. | portable | [Details + example](#forgezero-runtime-finance-chain-deposits) |
77
- | @forgezero/runtime/finance/chain-withdrawals | Provider-neutral withdrawal approval, broadcast and finality transitions. | portable | [Details + example](#forgezero-runtime-finance-chain-withdrawals) |
78
- | @forgezero/runtime/finance/chain-reconcile | Deterministic reconciliation between chain observations and durable transfer state. | portable | [Details + example](#forgezero-runtime-finance-chain-reconcile) |
79
- | @forgezero/runtime/finance/market | Market order, fill and quote contracts independent of any exchange adapter. | portable | [Details + example](#forgezero-runtime-finance-market) |
80
- | @forgezero/runtime/custody-share | Threshold-share parsing, validation and reconstruction. | portable | [Details + example](#forgezero-runtime-custody-share) |
81
- | @forgezero/runtime/custody-crypto | Hybrid ML-KEM-768 plus X25519 custody-share sealing and opening. | portable | [Details + example](#forgezero-runtime-custody-crypto) |
38
+ | @forgezero/runtime/query | Provider-neutral typed function contracts: decode untrusted input, run with caller-supplied services or storage, and strictly validate the result without coupling business logic to ForgeZero or ArangoDB. | portable | [Reference + usage](#forgezero-runtime-query) |
39
+ | @forgezero/runtime/jobs | Background work that never overlaps itself, advances a cursor only on success, and can be paused and inspected. | portable | [Reference + usage](#forgezero-runtime-jobs) |
40
+ | @forgezero/runtime/queue | Memory-only keyed work queue — awaited results, parallel across keys and strictly sequential within one; clustered callers atomically claim ownership in their own business store before submitting. | portable | [Reference + usage](#forgezero-runtime-queue) |
41
+ | @forgezero/runtime/outbox | Write the event with the record, deliver it after, in order per key with backoff and a dead-letter queue. | portable | [Reference + usage](#forgezero-runtime-outbox) |
42
+ | @forgezero/runtime/audit | Append-only records chained by hash, with a verifier that names the first altered entry. | portable | [Reference + usage](#forgezero-runtime-audit) |
43
+ | @forgezero/runtime/backup | Encrypted, chunked, verified snapshots to object storage — and the restore that reads them back. | portable | [Reference + usage](#forgezero-runtime-backup) |
44
+ | @forgezero/runtime/notify | Render a named template to text and HTML, escaped per part, refusing to send with a blank where a value should be. | portable | [Reference + usage](#forgezero-runtime-notify) |
45
+ | @forgezero/runtime/notify/templates | The six transactional messages ForgeZero sends. | portable | [Reference + usage](#forgezero-runtime-notify-templates) |
46
+ | @forgezero/runtime/calendar | Billing periods computed from an anchor, working days, holidays and due dates. | portable | [Reference + usage](#forgezero-runtime-calendar) |
47
+ | @forgezero/runtime/compliance | Screening as a decision record — tiers, rules and lists, failing closed when a list is unreachable. | portable | [Reference + usage](#forgezero-runtime-compliance) |
48
+ | @forgezero/runtime/totp | RFC 6238 TOTP on the existing HMAC — base32, an asymmetric window, and replay left to the caller. | portable | [Reference + usage](#forgezero-runtime-totp) |
49
+ | @forgezero/runtime/passkey | Passkeys for sites that are not us. A vault-held credential is as unphishable as one in a security chip provided the RP ID check never slips — `evil-example.com` ends with `example.com` and is a different site. | portable | [Reference + usage](#forgezero-runtime-passkey) |
50
+ | @forgezero/runtime/phrase | BIP-39 recovery phrases, and the salted verifier that proves one without being able to reconstruct it. | portable | [Reference + usage](#forgezero-runtime-phrase) |
51
+ | @forgezero/runtime/snp | Parse an AMD SEV-SNP attestation report at the firmware ABI offsets, and compare a TCB component by component so a microcode bump cannot mask a firmware downgrade. | portable | [Reference + usage](#forgezero-runtime-snp) |
52
+ | @forgezero/runtime/importers | Read secrets out of a .env, a CSV, or a Bitwarden or 1Password export — skipping what cannot be understood rather than guessing, and never putting a value in an error. | portable | [Reference + usage](#forgezero-runtime-importers) |
53
+ | @forgezero/runtime/openssh | OpenSSH wire encoding, so a derived ed25519 key becomes a line that pastes into authorized_keys. | portable | [Reference + usage](#forgezero-runtime-openssh) |
54
+ | @forgezero/runtime/ssh-cert | OpenSSH certificates, so access expires instead of having to be hunted down. Takes a signing FUNCTION rather than a secret key, which is what lets the CA live in a vault that never hands it out. | portable | [Reference + usage](#forgezero-runtime-ssh-cert) |
55
+ | @forgezero/runtime/slip10 | SLIP-0010 derivation for ed25519, hardened-only — BIP-32 does not work on this curve and produces halves that do not correspond. | portable | [Reference + usage](#forgezero-runtime-slip10) |
56
+ | @forgezero/runtime/identity | Hybrid Ed25519 + ML-DSA-65 request signing. One canonical string, so the compute agent that signs inside a guest and the API that verifies cannot drift — which two implementations of it certainly would. | portable | [Reference + usage](#forgezero-runtime-identity) |
57
+ | @forgezero/runtime/schema | Validate against JSON Schema, restrict what a caller may declare, and describe a schema as a form. | portable | [Reference + usage](#forgezero-runtime-schema) |
58
+ | @forgezero/runtime/schema/typebox | The TypeBox validator behind that interface. | portable | [Reference + usage](#forgezero-runtime-schema-typebox) |
59
+ | @forgezero/runtime/finance/discounts | Promotions as arithmetic over integer minor units. They never stack — one winner — and a percentage rounds down, because rounding a discount up gives away a unit of currency per invoice forever. | portable | [Reference + usage](#forgezero-runtime-finance-discounts) |
60
+ | @forgezero/runtime/finance/money | Exact amounts in minor units with the asset attached, so two currencies cannot be added. | portable | [Reference + usage](#forgezero-runtime-finance-money) |
61
+ | @forgezero/runtime/finance/venues | Trading venues, market types and symbols as data — spot, margin and futures behind one order model. | portable | [Reference + usage](#forgezero-runtime-finance-venues) |
62
+ | @forgezero/runtime/finance/ledger | Double-entry postings and derived balances. A hold is a posting, not a lock — the queue does the ordering. | portable | [Reference + usage](#forgezero-runtime-finance-ledger) |
63
+ | @forgezero/runtime/finance/commission | Profit net of flows, a high-water mark, the tier split and the referral share of our income. | portable | [Reference + usage](#forgezero-runtime-finance-commission) |
64
+ | @forgezero/runtime/finance/rates | What an asset is worth in USD, and how old that answer is. A peg never ages; a quote always does. | portable | [Reference + usage](#forgezero-runtime-finance-rates) |
65
+ | @forgezero/runtime/finance/transfers | Deposits and withdrawals as ordered pipelines, with screening reserved at position zero. | portable | [Reference + usage](#forgezero-runtime-finance-transfers) |
66
+ | @forgezero/runtime/finance/chain | Which chains exist, their confirmation depth by value band, assets and explorers — as data an admin edits. | portable | [Reference + usage](#forgezero-runtime-finance-chain) |
67
+ | @forgezero/runtime/finance/custody | Derive CREATE2 deposit addresses and EIP-712 custody digests — arithmetic over a seed and a salt, needing no credential and no node. | portable | [Reference + usage](#forgezero-runtime-finance-custody) |
68
+ | @forgezero/runtime/finance/derive | Declare a field ForgeZero generates rather than the tenant supplying: BIP-44 path arithmetic, and the choice of who is capable of generating the key. | portable | [Reference + usage](#forgezero-runtime-finance-derive) |
69
+ | @forgezero/runtime/finance/tax | Which jurisdiction may tax a sale, who accounts for it, and the three ways to be zero that report differently. Rates are data. | portable | [Reference + usage](#forgezero-runtime-finance-tax) |
70
+ | @forgezero/runtime/finance/storage | Write an amount so it is both exact and sortable: an authoritative string, and a number that is only an index. | portable | [Reference + usage](#forgezero-runtime-finance-storage) |
71
+ | @forgezero/runtime/realtime | Provider-neutral realtime audience, shard, event and delivery contracts. | portable | [Reference + usage](#forgezero-runtime-realtime) |
72
+ | @forgezero/runtime/passkey-hybrid | Versioned WebAuthn PRF plus ML-DSA companion proof construction and verification. | portable | [Reference + usage](#forgezero-runtime-passkey-hybrid) |
73
+ | @forgezero/runtime/otpauth | Parse and render otpauth URIs without binding enrolment to a UI framework. | portable | [Reference + usage](#forgezero-runtime-otpauth) |
74
+ | @forgezero/runtime/pipeline | Typed ordered application-pipeline execution with explicit evidence. | portable | [Reference + usage](#forgezero-runtime-pipeline) |
75
+ | @forgezero/runtime/finance/chain-addresses | Chain-address derivation records and validation independent of a node provider. | portable | [Reference + usage](#forgezero-runtime-finance-chain-addresses) |
76
+ | @forgezero/runtime/finance/chain-deposits | Provider-neutral deposit observation, confirmation and credit transitions. | portable | [Reference + usage](#forgezero-runtime-finance-chain-deposits) |
77
+ | @forgezero/runtime/finance/chain-withdrawals | Provider-neutral withdrawal approval, broadcast and finality transitions. | portable | [Reference + usage](#forgezero-runtime-finance-chain-withdrawals) |
78
+ | @forgezero/runtime/finance/chain-reconcile | Deterministic reconciliation between chain observations and durable transfer state. | portable | [Reference + usage](#forgezero-runtime-finance-chain-reconcile) |
79
+ | @forgezero/runtime/finance/market | Market order, fill and quote contracts independent of any exchange adapter. | portable | [Reference + usage](#forgezero-runtime-finance-market) |
80
+ | @forgezero/runtime/custody-share | Threshold-share parsing, validation and reconstruction. | portable | [Reference + usage](#forgezero-runtime-custody-share) |
81
+ | @forgezero/runtime/custody-crypto | Hybrid ML-KEM-768 plus X25519 custody-share sealing and opening. | portable | [Reference + usage](#forgezero-runtime-custody-crypto) |
82
82
 
83
83
  ## Commands
84
84
 
@@ -91,12 +91,25 @@ bun add @forgezero/runtime
91
91
  <a id="forgezero-runtime-query"></a>
92
92
  ## @forgezero/runtime/query
93
93
 
94
- Provider-neutral typed function contracts: decode untrusted input, run with caller-supplied services or storage, and strictly validate the result without coupling business logic to ForgeZero or ArangoDB. Named value imports: QueryContractError, defineQuery, implementQuery. Named type imports: QueryCodec, QueryContract, QueryDecode, QueryExecution, QueryImplementation, QueryInput, QueryIssue, QueryOutput. Import only the names used by this file.
94
+ Provider-neutral typed function contracts: decode untrusted input, run with caller-supplied services or storage, and strictly validate the result without coupling business logic to ForgeZero or ArangoDB. This entry exposes 3 named value exports and 8 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
95
95
 
96
96
  ```text
97
- import { QueryContractError, defineQuery, implementQuery } from '@forgezero/runtime/query';
98
- import type { QueryCodec, QueryContract, QueryDecode, QueryExecution, QueryImplementation, QueryInput } from '@forgezero/runtime/query';
99
- import type { QueryIssue, QueryOutput } from '@forgezero/runtime/query';
97
+ import {
98
+ QueryContractError,
99
+ defineQuery,
100
+ implementQuery,
101
+ } from '@forgezero/runtime/query';
102
+
103
+ import type {
104
+ QueryCodec,
105
+ QueryContract,
106
+ QueryDecode,
107
+ QueryExecution,
108
+ QueryImplementation,
109
+ QueryInput,
110
+ QueryIssue,
111
+ QueryOutput,
112
+ } from '@forgezero/runtime/query';
100
113
  ```
101
114
 
102
115
  ## @forgezero/runtime/query — Define and implement a typed query
@@ -104,8 +117,15 @@ import type { QueryIssue, QueryOutput } from '@forgezero/runtime/query';
104
117
  Decode untrusted input and validate output around injected storage/services rather than embedding a database query in the route adapter.
105
118
 
106
119
  ```text
107
- import { defineQuery, implementQuery } from '@forgezero/runtime/query';
108
- import { T, type Static, typeboxQueryCodec } from '@forgezero/runtime/schema/typebox';
120
+ import {
121
+ defineQuery,
122
+ implementQuery,
123
+ } from '@forgezero/runtime/query';
124
+ import {
125
+ T,
126
+ type Static,
127
+ typeboxQueryCodec,
128
+ } from '@forgezero/runtime/schema/typebox';
109
129
 
110
130
  const OrderKey = T.Object({ orderKey: T.String({ minLength: 1 }) });
111
131
  const Order = T.Object({ orderKey: T.String(), total: T.String() });
@@ -128,214 +148,740 @@ const order = await runFindOrder.execute(stores, { orderKey: 'ord_123' });
128
148
  <a id="forgezero-runtime-jobs"></a>
129
149
  ## @forgezero/runtime/jobs
130
150
 
131
- Background work that never overlaps itself, advances a cursor only on success, and can be paused and inspected. Named value imports: VERSION, createScheduler, cursorJob, defineJob, everyMs, memoryLock, nextWallClockAt, storeLock, systemClock. Named type imports: Clock, CursorBatch, CursorJobSpec, CursorStore, JobContext, JobLock, JobReport, JobResult, JobSpec, Lease, LockStore, Scheduler, SchedulerOptions, WallClockSchedule. Import only the names used by this file.
151
+ Background work that never overlaps itself, advances a cursor only on success, and can be paused and inspected. This entry exposes 12 named value exports and 14 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
132
152
 
133
153
  ```text
134
- import { VERSION, createScheduler, cursorJob, defineJob, everyMs, memoryLock } from '@forgezero/runtime/jobs';
135
- import { nextWallClockAt, storeLock, systemClock } from '@forgezero/runtime/jobs';
136
- import type { Clock, CursorBatch, CursorJobSpec, CursorStore, JobContext, JobLock } from '@forgezero/runtime/jobs';
137
- import type { JobReport, JobResult, JobSpec, Lease, LockStore, Scheduler } from '@forgezero/runtime/jobs';
138
- import type { SchedulerOptions, WallClockSchedule } from '@forgezero/runtime/jobs';
154
+ import {
155
+ JobFenceLostError,
156
+ VERSION,
157
+ createScheduler,
158
+ cursorJob,
159
+ defineJob,
160
+ everyMs,
161
+ forEachFenced,
162
+ memoryLock,
163
+ nextWallClockAt,
164
+ storeLock,
165
+ systemClock,
166
+ withJobFence,
167
+ } from '@forgezero/runtime/jobs';
168
+
169
+ import type {
170
+ Clock,
171
+ CursorBatch,
172
+ CursorJobSpec,
173
+ CursorStore,
174
+ JobContext,
175
+ JobLock,
176
+ JobReport,
177
+ JobResult,
178
+ JobSpec,
179
+ Lease,
180
+ LockStore,
181
+ Scheduler,
182
+ SchedulerOptions,
183
+ WallClockSchedule,
184
+ } from '@forgezero/runtime/jobs';
185
+ ```
186
+
187
+ ## @forgezero/runtime/jobs — Use this entry point
188
+
189
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
190
+
191
+ ```text
192
+ import {
193
+ JobFenceLostError,
194
+ } from '@forgezero/runtime/jobs';
195
+
196
+ export const selectedCapability = JobFenceLostError;
139
197
  ```
140
198
 
141
199
  <a id="forgezero-runtime-queue"></a>
142
200
  ## @forgezero/runtime/queue
143
201
 
144
- Memory-only keyed work queue — awaited results, parallel across keys and strictly sequential within one; clustered callers atomically claim ownership in their own business store before submitting. Named value imports: QueueKeyStoppedError, QueueStoppedError, TaskCancelledError, createQueue, queueWidthFor. Named type imports: DrainReport, Queue, QueueOptions, QueueResourcePolicy, QueueTask, RetryPolicy. Import only the names used by this file.
202
+ Memory-only keyed work queue — awaited results, parallel across keys and strictly sequential within one; clustered callers atomically claim ownership in their own business store before submitting. This entry exposes 5 named value exports and 6 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
203
+
204
+ ```text
205
+ import {
206
+ QueueKeyStoppedError,
207
+ QueueStoppedError,
208
+ TaskCancelledError,
209
+ createQueue,
210
+ queueWidthFor,
211
+ } from '@forgezero/runtime/queue';
212
+
213
+ import type {
214
+ DrainReport,
215
+ Queue,
216
+ QueueOptions,
217
+ QueueResourcePolicy,
218
+ QueueTask,
219
+ RetryPolicy,
220
+ } from '@forgezero/runtime/queue';
221
+ ```
222
+
223
+ ## @forgezero/runtime/queue — Use this entry point
224
+
225
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
145
226
 
146
227
  ```text
147
- import { QueueKeyStoppedError, QueueStoppedError, TaskCancelledError, createQueue, queueWidthFor } from '@forgezero/runtime/queue';
148
- import type { DrainReport, Queue, QueueOptions, QueueResourcePolicy, QueueTask, RetryPolicy } from '@forgezero/runtime/queue';
228
+ import {
229
+ QueueKeyStoppedError,
230
+ } from '@forgezero/runtime/queue';
231
+
232
+ export const selectedCapability = QueueKeyStoppedError;
149
233
  ```
150
234
 
151
235
  <a id="forgezero-runtime-outbox"></a>
152
236
  ## @forgezero/runtime/outbox
153
237
 
154
- Write the event with the record, deliver it after, in order per key with backoff and a dead-letter queue. Named value imports: DEFAULT_POLICY, EVENT_STATES, OutboxError, VERSION, backoffMs, createOutbox, memoryStore, outboxJob. Named type imports: DeliveryPolicy, DeliveryResult, DrainReport, EventState, Outbox, OutboxEvent, OutboxOptions, OutboxStore, PublishInput, Transport. Import only the names used by this file.
238
+ Write the event with the record, deliver it after, in order per key with backoff and a dead-letter queue. This entry exposes 8 named value exports and 10 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
239
+
240
+ ```text
241
+ import {
242
+ DEFAULT_POLICY,
243
+ EVENT_STATES,
244
+ OutboxError,
245
+ VERSION,
246
+ backoffMs,
247
+ createOutbox,
248
+ memoryStore,
249
+ outboxJob,
250
+ } from '@forgezero/runtime/outbox';
251
+
252
+ import type {
253
+ DeliveryPolicy,
254
+ DeliveryResult,
255
+ DrainReport,
256
+ EventState,
257
+ Outbox,
258
+ OutboxEvent,
259
+ OutboxOptions,
260
+ OutboxStore,
261
+ PublishInput,
262
+ Transport,
263
+ } from '@forgezero/runtime/outbox';
264
+ ```
265
+
266
+ ## @forgezero/runtime/outbox — Use this entry point
267
+
268
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
155
269
 
156
270
  ```text
157
- import { DEFAULT_POLICY, EVENT_STATES, OutboxError, VERSION, backoffMs, createOutbox } from '@forgezero/runtime/outbox';
158
- import { memoryStore, outboxJob } from '@forgezero/runtime/outbox';
159
- import type { DeliveryPolicy, DeliveryResult, DrainReport, EventState, Outbox, OutboxEvent } from '@forgezero/runtime/outbox';
160
- import type { OutboxOptions, OutboxStore, PublishInput, Transport } from '@forgezero/runtime/outbox';
271
+ import {
272
+ DEFAULT_POLICY,
273
+ } from '@forgezero/runtime/outbox';
274
+
275
+ export const selectedCapability = DEFAULT_POLICY;
161
276
  ```
162
277
 
163
278
  <a id="forgezero-runtime-audit"></a>
164
279
  ## @forgezero/runtime/audit
165
280
 
166
- Append-only records chained by hash, with a verifier that names the first altered entry. Named value imports: AuditChainError, GENESIS_DIGEST, VERSION, appendRecord, canonicalise, createAuditChain, exportRange, hashDigester, memoryStore, sealedDigester, verifyChain, verifyExport. Named type imports: AppendOptions, AuditChain, AuditChainOptions, AuditEntry, AuditExport, AuditRecord, AuditStore, ChainVerdict, Digester, EffectAuditRecord. Import only the names used by this file.
281
+ Append-only records chained by hash, with a verifier that names the first altered entry. This entry exposes 12 named value exports and 12 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
282
+
283
+ ```text
284
+ import {
285
+ AuditChainError,
286
+ GENESIS_DIGEST,
287
+ VERSION,
288
+ appendRecord,
289
+ canonicalise,
290
+ createAuditChain,
291
+ exportRange,
292
+ hashDigester,
293
+ memoryStore,
294
+ sealedDigester,
295
+ verifyChain,
296
+ verifyExport,
297
+ } from '@forgezero/runtime/audit';
298
+
299
+ import type {
300
+ AppendOptions,
301
+ AuditChain,
302
+ AuditChainOptions,
303
+ AuditDigesterResolver,
304
+ AuditEntry,
305
+ AuditExport,
306
+ AuditRecord,
307
+ AuditStore,
308
+ AuditVerifyOptions,
309
+ ChainVerdict,
310
+ Digester,
311
+ EffectAuditRecord,
312
+ } from '@forgezero/runtime/audit';
313
+ ```
314
+
315
+ ## @forgezero/runtime/audit — Use this entry point
316
+
317
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
167
318
 
168
319
  ```text
169
- import { AuditChainError, GENESIS_DIGEST, VERSION, appendRecord, canonicalise, createAuditChain } from '@forgezero/runtime/audit';
170
- import { exportRange, hashDigester, memoryStore, sealedDigester, verifyChain, verifyExport } from '@forgezero/runtime/audit';
171
- import type { AppendOptions, AuditChain, AuditChainOptions, AuditEntry, AuditExport, AuditRecord } from '@forgezero/runtime/audit';
172
- import type { AuditStore, ChainVerdict, Digester, EffectAuditRecord } from '@forgezero/runtime/audit';
320
+ import {
321
+ AuditChainError,
322
+ } from '@forgezero/runtime/audit';
323
+
324
+ export const selectedCapability = AuditChainError;
173
325
  ```
174
326
 
175
327
  <a id="forgezero-runtime-backup"></a>
176
328
  ## @forgezero/runtime/backup
177
329
 
178
- Encrypted, chunked, verified snapshots to object storage — and the restore that reads them back. Named value imports: BackupError, DEFAULT_RETENTION, SNAPSHOT_FORMAT, VERSION, backupJob, listSnapshots, prune, restore, selectForDeletion, snapshot, verifySnapshot. Named type imports: ChunkRecord, ObjectStore, RestoreOptions, RestoreReport, RetentionPolicy, RowSink, RowSource, SnapshotManifest, SnapshotOptions, VerifyReport. Import only the names used by this file.
330
+ Encrypted, chunked, verified snapshots to object storage — and the restore that reads them back. This entry exposes 11 named value exports and 10 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
179
331
 
180
332
  ```text
181
- import { BackupError, DEFAULT_RETENTION, SNAPSHOT_FORMAT, VERSION, backupJob, listSnapshots } from '@forgezero/runtime/backup';
182
- import { prune, restore, selectForDeletion, snapshot, verifySnapshot } from '@forgezero/runtime/backup';
183
- import type { ChunkRecord, ObjectStore, RestoreOptions, RestoreReport, RetentionPolicy, RowSink } from '@forgezero/runtime/backup';
184
- import type { RowSource, SnapshotManifest, SnapshotOptions, VerifyReport } from '@forgezero/runtime/backup';
333
+ import {
334
+ BackupError,
335
+ DEFAULT_RETENTION,
336
+ SNAPSHOT_FORMAT,
337
+ VERSION,
338
+ backupJob,
339
+ listSnapshots,
340
+ prune,
341
+ restore,
342
+ selectForDeletion,
343
+ snapshot,
344
+ verifySnapshot,
345
+ } from '@forgezero/runtime/backup';
346
+
347
+ import type {
348
+ ChunkRecord,
349
+ ObjectStore,
350
+ RestoreOptions,
351
+ RestoreReport,
352
+ RetentionPolicy,
353
+ RowSink,
354
+ RowSource,
355
+ SnapshotManifest,
356
+ SnapshotOptions,
357
+ VerifyReport,
358
+ } from '@forgezero/runtime/backup';
359
+ ```
360
+
361
+ ## @forgezero/runtime/backup — Use this entry point
362
+
363
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
364
+
365
+ ```text
366
+ import {
367
+ BackupError,
368
+ } from '@forgezero/runtime/backup';
369
+
370
+ export const selectedCapability = BackupError;
185
371
  ```
186
372
 
187
373
  <a id="forgezero-runtime-notify"></a>
188
374
  ## @forgezero/runtime/notify
189
375
 
190
- Render a named template to text and HTML, escaped per part, refusing to send with a blank where a value should be. Named value imports: CHANNELS, NotifyError, VERSION, assertHeaderSafe, button, codeBlock, createNotifier, defineTemplate, escapeHtml, layout, preview, render. Named type imports: Channel, Notification, Notifier, NotifierOptions, Rendered, TemplateSpec, Transport. Import only the names used by this file.
376
+ Render a named template to text and HTML, escaped per part, refusing to send with a blank where a value should be. This entry exposes 12 named value exports and 7 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
191
377
 
192
378
  ```text
193
- import { CHANNELS, NotifyError, VERSION, assertHeaderSafe, button, codeBlock } from '@forgezero/runtime/notify';
194
- import { createNotifier, defineTemplate, escapeHtml, layout, preview, render } from '@forgezero/runtime/notify';
195
- import type { Channel, Notification, Notifier, NotifierOptions, Rendered, TemplateSpec } from '@forgezero/runtime/notify';
196
- import type { Transport } from '@forgezero/runtime/notify';
379
+ import {
380
+ CHANNELS,
381
+ NotifyError,
382
+ VERSION,
383
+ assertHeaderSafe,
384
+ button,
385
+ codeBlock,
386
+ createNotifier,
387
+ defineTemplate,
388
+ escapeHtml,
389
+ layout,
390
+ preview,
391
+ render,
392
+ } from '@forgezero/runtime/notify';
393
+
394
+ import type {
395
+ Channel,
396
+ Notification,
397
+ Notifier,
398
+ NotifierOptions,
399
+ Rendered,
400
+ TemplateSpec,
401
+ Transport,
402
+ } from '@forgezero/runtime/notify';
403
+ ```
404
+
405
+ ## @forgezero/runtime/notify — Use this entry point
406
+
407
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
408
+
409
+ ```text
410
+ import {
411
+ CHANNELS,
412
+ } from '@forgezero/runtime/notify';
413
+
414
+ export const selectedCapability = CHANNELS;
197
415
  ```
198
416
 
199
417
  <a id="forgezero-runtime-notify-templates"></a>
200
418
  ## @forgezero/runtime/notify/templates
201
419
 
202
- The six transactional messages ForgeZero sends. Named value imports: TEMPLATES, ceremonyProposed, custodianEnrolment, escapeHtml, invitation, newDevice, signInCode, vaultLocked. Named type imports: TemplateKey. Import only the names used by this file.
420
+ The six transactional messages ForgeZero sends. This entry exposes 8 named value exports and 1 named type export. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
421
+
422
+ ```text
423
+ import {
424
+ TEMPLATES,
425
+ ceremonyProposed,
426
+ custodianEnrolment,
427
+ escapeHtml,
428
+ invitation,
429
+ newDevice,
430
+ signInCode,
431
+ vaultLocked,
432
+ } from '@forgezero/runtime/notify/templates';
433
+
434
+ import type {
435
+ TemplateKey,
436
+ } from '@forgezero/runtime/notify/templates';
437
+ ```
438
+
439
+ ## @forgezero/runtime/notify/templates — Use this entry point
440
+
441
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
203
442
 
204
443
  ```text
205
- import { TEMPLATES, ceremonyProposed, custodianEnrolment, escapeHtml, invitation, newDevice } from '@forgezero/runtime/notify/templates';
206
- import { signInCode, vaultLocked } from '@forgezero/runtime/notify/templates';
207
- import type { TemplateKey } from '@forgezero/runtime/notify/templates';
444
+ import {
445
+ TEMPLATES,
446
+ } from '@forgezero/runtime/notify/templates';
447
+
448
+ export const selectedCapability = TEMPLATES;
208
449
  ```
209
450
 
210
451
  <a id="forgezero-runtime-calendar"></a>
211
452
  ## @forgezero/runtime/calendar
212
453
 
213
- Billing periods computed from an anchor, working days, holidays and due dates. Named value imports: CalendarError, DAY_MS, DEFAULT_WORKING_DAYS, closedPeriods, dayOfWeek, daysOverdue, fromDay, isOverdue, isWorkingDay, nextWorkingDay, periodAt, periodIndexOn, periodOn, toDay, workingDaysBetween. Named type imports: BillingSchedule, Calendar, IsoDate, Period. Import only the names used by this file.
454
+ Billing periods computed from an anchor, working days, holidays and due dates. This entry exposes 15 named value exports and 4 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
455
+
456
+ ```text
457
+ import {
458
+ CalendarError,
459
+ DAY_MS,
460
+ DEFAULT_WORKING_DAYS,
461
+ closedPeriods,
462
+ dayOfWeek,
463
+ daysOverdue,
464
+ fromDay,
465
+ isOverdue,
466
+ isWorkingDay,
467
+ nextWorkingDay,
468
+ periodAt,
469
+ periodIndexOn,
470
+ periodOn,
471
+ toDay,
472
+ workingDaysBetween,
473
+ } from '@forgezero/runtime/calendar';
474
+
475
+ import type {
476
+ BillingSchedule,
477
+ Calendar,
478
+ IsoDate,
479
+ Period,
480
+ } from '@forgezero/runtime/calendar';
481
+ ```
482
+
483
+ ## @forgezero/runtime/calendar — Use this entry point
484
+
485
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
214
486
 
215
487
  ```text
216
- import { CalendarError, DAY_MS, DEFAULT_WORKING_DAYS, closedPeriods, dayOfWeek, daysOverdue } from '@forgezero/runtime/calendar';
217
- import { fromDay, isOverdue, isWorkingDay, nextWorkingDay, periodAt, periodIndexOn } from '@forgezero/runtime/calendar';
218
- import { periodOn, toDay, workingDaysBetween } from '@forgezero/runtime/calendar';
219
- import type { BillingSchedule, Calendar, IsoDate, Period } from '@forgezero/runtime/calendar';
488
+ import {
489
+ CalendarError,
490
+ } from '@forgezero/runtime/calendar';
491
+
492
+ export const selectedCapability = CalendarError;
220
493
  ```
221
494
 
222
495
  <a id="forgezero-runtime-compliance"></a>
223
496
  ## @forgezero/runtime/compliance
224
497
 
225
- Screening as a decision record — tiers, rules and lists, failing closed when a list is unreachable. Named value imports: ComplianceError, RISK_LEVELS, VERIFICATION_TIERS, combineLists, countryRule, newCounterpartyRule, screen, screeningStage, staticList, tierLimitRule, unavailableList. Named type imports: ListEntry, RiskLevel, Rule, RuleHit, ScreenOptions, ScreeningList, StageOptions, Subject, Verdict, VerificationTier. Import only the names used by this file.
498
+ Screening as a decision record — tiers, rules and lists, failing closed when a list is unreachable. This entry exposes 11 named value exports and 10 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
499
+
500
+ ```text
501
+ import {
502
+ ComplianceError,
503
+ RISK_LEVELS,
504
+ VERIFICATION_TIERS,
505
+ combineLists,
506
+ countryRule,
507
+ newCounterpartyRule,
508
+ screen,
509
+ screeningStage,
510
+ staticList,
511
+ tierLimitRule,
512
+ unavailableList,
513
+ } from '@forgezero/runtime/compliance';
514
+
515
+ import type {
516
+ ListEntry,
517
+ RiskLevel,
518
+ Rule,
519
+ RuleHit,
520
+ ScreenOptions,
521
+ ScreeningList,
522
+ StageOptions,
523
+ Subject,
524
+ Verdict,
525
+ VerificationTier,
526
+ } from '@forgezero/runtime/compliance';
527
+ ```
528
+
529
+ ## @forgezero/runtime/compliance — Use this entry point
530
+
531
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
226
532
 
227
533
  ```text
228
- import { ComplianceError, RISK_LEVELS, VERIFICATION_TIERS, combineLists, countryRule, newCounterpartyRule } from '@forgezero/runtime/compliance';
229
- import { screen, screeningStage, staticList, tierLimitRule, unavailableList } from '@forgezero/runtime/compliance';
230
- import type { ListEntry, RiskLevel, Rule, RuleHit, ScreenOptions, ScreeningList } from '@forgezero/runtime/compliance';
231
- import type { StageOptions, Subject, Verdict, VerificationTier } from '@forgezero/runtime/compliance';
534
+ import {
535
+ ComplianceError,
536
+ } from '@forgezero/runtime/compliance';
537
+
538
+ export const selectedCapability = ComplianceError;
232
539
  ```
233
540
 
234
541
  <a id="forgezero-runtime-totp"></a>
235
542
  ## @forgezero/runtime/totp
236
543
 
237
- RFC 6238 TOTP on the existing HMAC — base32, an asymmetric window, and replay left to the caller. Named value imports: DEFAULT_DIGITS, DEFAULT_STEP_SECONDS, TotpError, assertCode, codeAt, codeFor, counterAt, enrolmentUri, fromBase32, generateSecret, secondsRemaining, toBase32, verifyCode. Named type imports: TotpOptions, VerifyOptions, VerifyResult. Import only the names used by this file.
544
+ RFC 6238 TOTP on the existing HMAC — base32, an asymmetric window, and replay left to the caller. This entry exposes 13 named value exports and 3 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
238
545
 
239
546
  ```text
240
- import { DEFAULT_DIGITS, DEFAULT_STEP_SECONDS, TotpError, assertCode, codeAt, codeFor } from '@forgezero/runtime/totp';
241
- import { counterAt, enrolmentUri, fromBase32, generateSecret, secondsRemaining, toBase32 } from '@forgezero/runtime/totp';
242
- import { verifyCode } from '@forgezero/runtime/totp';
243
- import type { TotpOptions, VerifyOptions, VerifyResult } from '@forgezero/runtime/totp';
547
+ import {
548
+ DEFAULT_DIGITS,
549
+ DEFAULT_STEP_SECONDS,
550
+ TotpError,
551
+ assertCode,
552
+ codeAt,
553
+ codeFor,
554
+ counterAt,
555
+ enrolmentUri,
556
+ fromBase32,
557
+ generateSecret,
558
+ secondsRemaining,
559
+ toBase32,
560
+ verifyCode,
561
+ } from '@forgezero/runtime/totp';
562
+
563
+ import type {
564
+ TotpOptions,
565
+ VerifyOptions,
566
+ VerifyResult,
567
+ } from '@forgezero/runtime/totp';
568
+ ```
569
+
570
+ ## @forgezero/runtime/totp — Use this entry point
571
+
572
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
573
+
574
+ ```text
575
+ import {
576
+ DEFAULT_DIGITS,
577
+ } from '@forgezero/runtime/totp';
578
+
579
+ export const selectedCapability = DEFAULT_DIGITS;
244
580
  ```
245
581
 
246
582
  <a id="forgezero-runtime-passkey"></a>
247
583
  ## @forgezero/runtime/passkey
248
584
 
249
- Passkeys for sites that are not us. A vault-held credential is as unphishable as one in a security chip provided the RP ID check never slips — `evil-example.com` ends with `example.com` and is a different site. Named value imports: FLAG_BE, FLAG_BS, FLAG_UP, FLAG_UV, PasskeyError, assertPasskey, authenticatorData, credentialIdFor, passkeysFor, rpIdMatches, verifyAssertion. Named type imports: Assertion, AssertionRequest, StoredPasskey. Import only the names used by this file.
585
+ Passkeys for sites that are not us. A vault-held credential is as unphishable as one in a security chip provided the RP ID check never slips — `evil-example.com` ends with `example.com` and is a different site. This entry exposes 11 named value exports and 3 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
586
+
587
+ ```text
588
+ import {
589
+ FLAG_BE,
590
+ FLAG_BS,
591
+ FLAG_UP,
592
+ FLAG_UV,
593
+ PasskeyError,
594
+ assertPasskey,
595
+ authenticatorData,
596
+ credentialIdFor,
597
+ passkeysFor,
598
+ rpIdMatches,
599
+ verifyAssertion,
600
+ } from '@forgezero/runtime/passkey';
601
+
602
+ import type {
603
+ Assertion,
604
+ AssertionRequest,
605
+ StoredPasskey,
606
+ } from '@forgezero/runtime/passkey';
607
+ ```
608
+
609
+ ## @forgezero/runtime/passkey — Use this entry point
610
+
611
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
250
612
 
251
613
  ```text
252
- import { FLAG_BE, FLAG_BS, FLAG_UP, FLAG_UV, PasskeyError, assertPasskey } from '@forgezero/runtime/passkey';
253
- import { authenticatorData, credentialIdFor, passkeysFor, rpIdMatches, verifyAssertion } from '@forgezero/runtime/passkey';
254
- import type { Assertion, AssertionRequest, StoredPasskey } from '@forgezero/runtime/passkey';
614
+ import {
615
+ FLAG_BE,
616
+ } from '@forgezero/runtime/passkey';
617
+
618
+ export const selectedCapability = FLAG_BE;
255
619
  ```
256
620
 
257
621
  <a id="forgezero-runtime-phrase"></a>
258
622
  ## @forgezero/runtime/phrase
259
623
 
260
- BIP-39 recovery phrases, and the salted verifier that proves one without being able to reconstruct it. Named value imports: PHRASE_SALT_BYTES, PHRASE_WORDS, generatePhrase, newSalt, phraseToKey, phraseVerifier, validatePhrase. Named type imports: none. Import only the names used by this file.
624
+ BIP-39 recovery phrases, and the salted verifier that proves one without being able to reconstruct it. This entry exposes 7 named value exports and 0 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
625
+
626
+ ```text
627
+ import {
628
+ PHRASE_SALT_BYTES,
629
+ PHRASE_WORDS,
630
+ generatePhrase,
631
+ newSalt,
632
+ phraseToKey,
633
+ phraseVerifier,
634
+ validatePhrase,
635
+ } from '@forgezero/runtime/phrase';
636
+ ```
637
+
638
+ ## @forgezero/runtime/phrase — Use this entry point
639
+
640
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
261
641
 
262
642
  ```text
263
- import { PHRASE_SALT_BYTES, PHRASE_WORDS, generatePhrase, newSalt, phraseToKey, phraseVerifier } from '@forgezero/runtime/phrase';
264
- import { validatePhrase } from '@forgezero/runtime/phrase';
643
+ import {
644
+ PHRASE_SALT_BYTES,
645
+ } from '@forgezero/runtime/phrase';
646
+
647
+ export const selectedCapability = PHRASE_SALT_BYTES;
265
648
  ```
266
649
 
267
650
  <a id="forgezero-runtime-snp"></a>
268
651
  ## @forgezero/runtime/snp
269
652
 
270
- Parse an AMD SEV-SNP attestation report at the firmware ABI offsets, and compare a TCB component by component so a microcode bump cannot mask a firmware downgrade. Named value imports: REPORT_BYTES, SnpError, bindsNonce, parseSnpReport, tcbAtLeast. Named type imports: GuestPolicy, SnpReport, TcbVersion. Import only the names used by this file.
653
+ Parse an AMD SEV-SNP attestation report at the firmware ABI offsets, and compare a TCB component by component so a microcode bump cannot mask a firmware downgrade. This entry exposes 5 named value exports and 3 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
654
+
655
+ ```text
656
+ import {
657
+ REPORT_BYTES,
658
+ SnpError,
659
+ bindsNonce,
660
+ parseSnpReport,
661
+ tcbAtLeast,
662
+ } from '@forgezero/runtime/snp';
663
+
664
+ import type {
665
+ GuestPolicy,
666
+ SnpReport,
667
+ TcbVersion,
668
+ } from '@forgezero/runtime/snp';
669
+ ```
670
+
671
+ ## @forgezero/runtime/snp — Use this entry point
672
+
673
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
271
674
 
272
675
  ```text
273
- import { REPORT_BYTES, SnpError, bindsNonce, parseSnpReport, tcbAtLeast } from '@forgezero/runtime/snp';
274
- import type { GuestPolicy, SnpReport, TcbVersion } from '@forgezero/runtime/snp';
676
+ import {
677
+ REPORT_BYTES,
678
+ } from '@forgezero/runtime/snp';
679
+
680
+ export const selectedCapability = REPORT_BYTES;
275
681
  ```
276
682
 
277
683
  <a id="forgezero-runtime-importers"></a>
278
684
  ## @forgezero/runtime/importers
279
685
 
280
- Read secrets out of a .env, a CSV, or a Bitwarden or 1Password export — skipping what cannot be understood rather than guessing, and never putting a value in an error. Named value imports: IMPORT_FORMATS, normaliseName, parseBitwarden, parseCsv, parseEnv, parseImport, parseOnePassword. Named type imports: ImportFormat, ImportResult, ImportedSecret, Skipped. Import only the names used by this file.
686
+ Read secrets out of a .env, a CSV, or a Bitwarden or 1Password export — skipping what cannot be understood rather than guessing, and never putting a value in an error. This entry exposes 7 named value exports and 4 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
281
687
 
282
688
  ```text
283
- import { IMPORT_FORMATS, normaliseName, parseBitwarden, parseCsv, parseEnv, parseImport } from '@forgezero/runtime/importers';
284
- import { parseOnePassword } from '@forgezero/runtime/importers';
285
- import type { ImportFormat, ImportResult, ImportedSecret, Skipped } from '@forgezero/runtime/importers';
689
+ import {
690
+ IMPORT_FORMATS,
691
+ normaliseName,
692
+ parseBitwarden,
693
+ parseCsv,
694
+ parseEnv,
695
+ parseImport,
696
+ parseOnePassword,
697
+ } from '@forgezero/runtime/importers';
698
+
699
+ import type {
700
+ ImportFormat,
701
+ ImportResult,
702
+ ImportedSecret,
703
+ Skipped,
704
+ } from '@forgezero/runtime/importers';
705
+ ```
706
+
707
+ ## @forgezero/runtime/importers — Use this entry point
708
+
709
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
710
+
711
+ ```text
712
+ import {
713
+ IMPORT_FORMATS,
714
+ } from '@forgezero/runtime/importers';
715
+
716
+ export const selectedCapability = IMPORT_FORMATS;
286
717
  ```
287
718
 
288
719
  <a id="forgezero-runtime-openssh"></a>
289
720
  ## @forgezero/runtime/openssh
290
721
 
291
- OpenSSH wire encoding, so a derived ed25519 key becomes a line that pastes into authorized_keys. Named value imports: OpenSshError, authorizedKey, fingerprint, parseAuthorizedKey, publicKeyBlob, signatureBlob. Named type imports: none. Import only the names used by this file.
722
+ OpenSSH wire encoding, so a derived ed25519 key becomes a line that pastes into authorized_keys. This entry exposes 6 named value exports and 0 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
723
+
724
+ ```text
725
+ import {
726
+ OpenSshError,
727
+ authorizedKey,
728
+ fingerprint,
729
+ parseAuthorizedKey,
730
+ publicKeyBlob,
731
+ signatureBlob,
732
+ } from '@forgezero/runtime/openssh';
733
+ ```
734
+
735
+ ## @forgezero/runtime/openssh — Use this entry point
736
+
737
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
292
738
 
293
739
  ```text
294
- import { OpenSshError, authorizedKey, fingerprint, parseAuthorizedKey, publicKeyBlob, signatureBlob } from '@forgezero/runtime/openssh';
740
+ import {
741
+ OpenSshError,
742
+ } from '@forgezero/runtime/openssh';
743
+
744
+ export const selectedCapability = OpenSshError;
295
745
  ```
296
746
 
297
747
  <a id="forgezero-runtime-ssh-cert"></a>
298
748
  ## @forgezero/runtime/ssh-cert
299
749
 
300
- OpenSSH certificates, so access expires instead of having to be hunted down. Takes a signing FUNCTION rather than a secret key, which is what lets the CA live in a vault that never hands it out. Named value imports: CERT_TYPE_HOST, CERT_TYPE_USER, DEFAULT_EXTENSIONS, SshCertError, caFingerprint, caFromSecretKey, caPublicKeyLine, isCurrentlyValid, signCertificate. Named type imports: CertificateAuthority, CertificateRequest. Import only the names used by this file.
750
+ OpenSSH certificates, so access expires instead of having to be hunted down. Takes a signing FUNCTION rather than a secret key, which is what lets the CA live in a vault that never hands it out. This entry exposes 9 named value exports and 2 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
751
+
752
+ ```text
753
+ import {
754
+ CERT_TYPE_HOST,
755
+ CERT_TYPE_USER,
756
+ DEFAULT_EXTENSIONS,
757
+ SshCertError,
758
+ caFingerprint,
759
+ caFromSecretKey,
760
+ caPublicKeyLine,
761
+ isCurrentlyValid,
762
+ signCertificate,
763
+ } from '@forgezero/runtime/ssh-cert';
764
+
765
+ import type {
766
+ CertificateAuthority,
767
+ CertificateRequest,
768
+ } from '@forgezero/runtime/ssh-cert';
769
+ ```
770
+
771
+ ## @forgezero/runtime/ssh-cert — Use this entry point
772
+
773
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
301
774
 
302
775
  ```text
303
- import { CERT_TYPE_HOST, CERT_TYPE_USER, DEFAULT_EXTENSIONS, SshCertError, caFingerprint, caFromSecretKey } from '@forgezero/runtime/ssh-cert';
304
- import { caPublicKeyLine, isCurrentlyValid, signCertificate } from '@forgezero/runtime/ssh-cert';
305
- import type { CertificateAuthority, CertificateRequest } from '@forgezero/runtime/ssh-cert';
776
+ import {
777
+ CERT_TYPE_HOST,
778
+ } from '@forgezero/runtime/ssh-cert';
779
+
780
+ export const selectedCapability = CERT_TYPE_HOST;
306
781
  ```
307
782
 
308
783
  <a id="forgezero-runtime-slip10"></a>
309
784
  ## @forgezero/runtime/slip10
310
785
 
311
- SLIP-0010 derivation for ed25519, hardened-only — BIP-32 does not work on this curve and produces halves that do not correspond. Named value imports: HARDENED_OFFSET, Slip10Error, deriveChild, derivePath, masterFromSeed. Named type imports: Slip10Node. Import only the names used by this file.
786
+ SLIP-0010 derivation for ed25519, hardened-only — BIP-32 does not work on this curve and produces halves that do not correspond. This entry exposes 5 named value exports and 1 named type export. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
787
+
788
+ ```text
789
+ import {
790
+ HARDENED_OFFSET,
791
+ Slip10Error,
792
+ deriveChild,
793
+ derivePath,
794
+ masterFromSeed,
795
+ } from '@forgezero/runtime/slip10';
796
+
797
+ import type {
798
+ Slip10Node,
799
+ } from '@forgezero/runtime/slip10';
800
+ ```
801
+
802
+ ## @forgezero/runtime/slip10 — Use this entry point
803
+
804
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
312
805
 
313
806
  ```text
314
- import { HARDENED_OFFSET, Slip10Error, deriveChild, derivePath, masterFromSeed } from '@forgezero/runtime/slip10';
315
- import type { Slip10Node } from '@forgezero/runtime/slip10';
807
+ import {
808
+ HARDENED_OFFSET,
809
+ } from '@forgezero/runtime/slip10';
810
+
811
+ export const selectedCapability = HARDENED_OFFSET;
316
812
  ```
317
813
 
318
814
  <a id="forgezero-runtime-identity"></a>
319
815
  ## @forgezero/runtime/identity
320
816
 
321
- Hybrid Ed25519 + ML-DSA-65 request signing. One canonical string, so the compute agent that signs inside a guest and the API that verifies cannot drift — which two implementations of it certainly would. Named value imports: CLOCK_SKEW_SECONDS, REQUEST_SIGNATURE_SUITE, RESPONSE_KEY_HEADER, RESPONSE_SEALING_SUITE, canonicalString, decodeSignatureHeader, deriveKeysFromSeed, derivePublicKeysFromSeed, encodeSignatureHeader, generateNodeKeys, generateResponseRecipient, openResponse, sealResponse, signRequest, validResponsePublicKey, verifyRequest. Named type imports: NodeKeyPair, NodePublicKeys, ResponseRecipient, SealedResponse, SignedEnvelope, VerifyFailure. Import only the names used by this file.
817
+ Hybrid Ed25519 + ML-DSA-65 request signing. One canonical string, so the compute agent that signs inside a guest and the API that verifies cannot drift — which two implementations of it certainly would. This entry exposes 16 named value exports and 6 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
322
818
 
323
819
  ```text
324
- import { CLOCK_SKEW_SECONDS, REQUEST_SIGNATURE_SUITE, RESPONSE_KEY_HEADER, RESPONSE_SEALING_SUITE, canonicalString, decodeSignatureHeader } from '@forgezero/runtime/identity';
325
- import { deriveKeysFromSeed, derivePublicKeysFromSeed, encodeSignatureHeader, generateNodeKeys, generateResponseRecipient, openResponse } from '@forgezero/runtime/identity';
326
- import { sealResponse, signRequest, validResponsePublicKey, verifyRequest } from '@forgezero/runtime/identity';
327
- import type { NodeKeyPair, NodePublicKeys, ResponseRecipient, SealedResponse, SignedEnvelope, VerifyFailure } from '@forgezero/runtime/identity';
820
+ import {
821
+ CLOCK_SKEW_SECONDS,
822
+ REQUEST_SIGNATURE_SUITE,
823
+ RESPONSE_KEY_HEADER,
824
+ RESPONSE_SEALING_SUITE,
825
+ canonicalString,
826
+ decodeSignatureHeader,
827
+ deriveKeysFromSeed,
828
+ derivePublicKeysFromSeed,
829
+ encodeSignatureHeader,
830
+ generateNodeKeys,
831
+ generateResponseRecipient,
832
+ openResponse,
833
+ sealResponse,
834
+ signRequest,
835
+ validResponsePublicKey,
836
+ verifyRequest,
837
+ } from '@forgezero/runtime/identity';
838
+
839
+ import type {
840
+ NodeKeyPair,
841
+ NodePublicKeys,
842
+ ResponseRecipient,
843
+ SealedResponse,
844
+ SignedEnvelope,
845
+ VerifyFailure,
846
+ } from '@forgezero/runtime/identity';
847
+ ```
848
+
849
+ ## @forgezero/runtime/identity — Use this entry point
850
+
851
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
852
+
853
+ ```text
854
+ import {
855
+ CLOCK_SKEW_SECONDS,
856
+ } from '@forgezero/runtime/identity';
857
+
858
+ export const selectedCapability = CLOCK_SKEW_SECONDS;
328
859
  ```
329
860
 
330
861
  <a id="forgezero-runtime-schema"></a>
331
862
  ## @forgezero/runtime/schema
332
863
 
333
- Validate against JSON Schema, restrict what a caller may declare, and describe a schema as a form. Named value imports: DEFAULT_RESTRICTIONS, SCHEMA_VERSION, SchemaError, VERSION, describeJsonSchema, readableFields, restrictJsonSchema, writeOnlyPaths. Named type imports: FieldKind, FormField, Restrictions, SchemaValidator, ValidationResult. Import only the names used by this file.
864
+ Validate against JSON Schema, restrict what a caller may declare, and describe a schema as a form. This entry exposes 8 named value exports and 5 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
334
865
 
335
866
  ```text
336
- import { DEFAULT_RESTRICTIONS, SCHEMA_VERSION, SchemaError, VERSION, describeJsonSchema, readableFields } from '@forgezero/runtime/schema';
337
- import { restrictJsonSchema, writeOnlyPaths } from '@forgezero/runtime/schema';
338
- import type { FieldKind, FormField, Restrictions, SchemaValidator, ValidationResult } from '@forgezero/runtime/schema';
867
+ import {
868
+ DEFAULT_RESTRICTIONS,
869
+ SCHEMA_VERSION,
870
+ SchemaError,
871
+ VERSION,
872
+ describeJsonSchema,
873
+ readableFields,
874
+ restrictJsonSchema,
875
+ writeOnlyPaths,
876
+ } from '@forgezero/runtime/schema';
877
+
878
+ import type {
879
+ FieldKind,
880
+ FormField,
881
+ Restrictions,
882
+ SchemaValidator,
883
+ ValidationResult,
884
+ } from '@forgezero/runtime/schema';
339
885
  ```
340
886
 
341
887
  ## @forgezero/runtime/schema — Restrict an untrusted JSON Schema before storing it
@@ -343,7 +889,11 @@ import type { FieldKind, FormField, Restrictions, SchemaValidator, ValidationRes
343
889
  Tenant-supplied schemas are data, not executable code. Restriction rejects references, remote identifiers, unsupported keywords, excessive depth/size, and arrays without a bounded maxItems. Form metadata is derived from the accepted schema; write-only fields remain identifiable for secret handling.
344
890
 
345
891
  ```text
346
- import { restrictJsonSchema, describeJsonSchema, writeOnlyPaths } from '@forgezero/runtime/schema';
892
+ import {
893
+ restrictJsonSchema,
894
+ describeJsonSchema,
895
+ writeOnlyPaths,
896
+ } from '@forgezero/runtime/schema';
347
897
 
348
898
  const schema = restrictJsonSchema({
349
899
  type: 'object', additionalProperties: false,
@@ -360,11 +910,20 @@ const secretFields = writeOnlyPaths(fields);
360
910
  <a id="forgezero-runtime-schema-typebox"></a>
361
911
  ## @forgezero/runtime/schema/typebox
362
912
 
363
- The TypeBox validator behind that interface. Named value imports: T, parse, typebox, typeboxQueryCodec. Named type imports: Static, TSchema. Import only the names used by this file.
913
+ The TypeBox validator behind that interface. This entry exposes 4 named value exports and 2 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
364
914
 
365
915
  ```text
366
- import { T, parse, typebox, typeboxQueryCodec } from '@forgezero/runtime/schema/typebox';
367
- import type { Static, TSchema } from '@forgezero/runtime/schema/typebox';
916
+ import {
917
+ T,
918
+ parse,
919
+ typebox,
920
+ typeboxQueryCodec,
921
+ } from '@forgezero/runtime/schema/typebox';
922
+
923
+ import type {
924
+ Static,
925
+ TSchema,
926
+ } from '@forgezero/runtime/schema/typebox';
368
927
  ```
369
928
 
370
929
  ## @forgezero/runtime/schema/typebox — One TypeBox shape for runtime validation and static types
@@ -372,7 +931,12 @@ import type { Static, TSchema } from '@forgezero/runtime/schema/typebox';
372
931
  TypeBox is an optional peer. Its schema is JSON Schema, so the same restriction and form layer applies. The query codec validates both untrusted input and returned output; malformed values fail instead of being coerced.
373
932
 
374
933
  ```text
375
- import { T, type Static, parse, typeboxQueryCodec } from '@forgezero/runtime/schema/typebox';
934
+ import {
935
+ T,
936
+ type Static,
937
+ parse,
938
+ typeboxQueryCodec,
939
+ } from '@forgezero/runtime/schema/typebox';
376
940
 
377
941
  const User = T.Object({
378
942
  userKey: T.String({ minLength: 1 }),
@@ -386,260 +950,907 @@ const codec = typeboxQueryCodec(User);
386
950
  <a id="forgezero-runtime-finance-discounts"></a>
387
951
  ## @forgezero/runtime/finance/discounts
388
952
 
389
- Promotions as arithmetic over integer minor units. They never stack — one winner — and a percentage rounds down, because rounding a discount up gives away a unit of currency per invoice forever. Named value imports: DiscountError, assertCode, assertWindow, bestDiscount, discountFor, ineligibility, normaliseCode. Named type imports: AppliedDiscount, DiscountKind, Ineligibility, Promotion. Import only the names used by this file.
953
+ Promotions as arithmetic over integer minor units. They never stack — one winner — and a percentage rounds down, because rounding a discount up gives away a unit of currency per invoice forever. This entry exposes 7 named value exports and 4 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
390
954
 
391
955
  ```text
392
- import { DiscountError, assertCode, assertWindow, bestDiscount, discountFor, ineligibility } from '@forgezero/runtime/finance/discounts';
393
- import { normaliseCode } from '@forgezero/runtime/finance/discounts';
394
- import type { AppliedDiscount, DiscountKind, Ineligibility, Promotion } from '@forgezero/runtime/finance/discounts';
956
+ import {
957
+ DiscountError,
958
+ assertCode,
959
+ assertWindow,
960
+ bestDiscount,
961
+ discountFor,
962
+ ineligibility,
963
+ normaliseCode,
964
+ } from '@forgezero/runtime/finance/discounts';
965
+
966
+ import type {
967
+ AppliedDiscount,
968
+ DiscountKind,
969
+ Ineligibility,
970
+ Promotion,
971
+ } from '@forgezero/runtime/finance/discounts';
972
+ ```
973
+
974
+ ## @forgezero/runtime/finance/discounts — Use this entry point
975
+
976
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
977
+
978
+ ```text
979
+ import {
980
+ DiscountError,
981
+ } from '@forgezero/runtime/finance/discounts';
982
+
983
+ export const selectedCapability = DiscountError;
395
984
  ```
396
985
 
397
986
  <a id="forgezero-runtime-finance-money"></a>
398
987
  ## @forgezero/runtime/finance/money
399
988
 
400
- Exact amounts in minor units with the asset attached, so two currencies cannot be added. Named value imports: ASSETS, MoneyError, ROUNDING, VERSION, abs, add, allocate, assetSpec, compare, convert, defineAsset, equals, formatAmount, isNegative, isZero, money, mulRate, negate, parseAmount, subtract, toStep, zero. Named type imports: AssetSpec, Money, Rounding. Import only the names used by this file.
989
+ Exact amounts in minor units with the asset attached, so two currencies cannot be added. This entry exposes 22 named value exports and 3 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
990
+
991
+ ```text
992
+ import {
993
+ ASSETS,
994
+ MoneyError,
995
+ ROUNDING,
996
+ VERSION,
997
+ abs,
998
+ add,
999
+ allocate,
1000
+ assetSpec,
1001
+ compare,
1002
+ convert,
1003
+ defineAsset,
1004
+ equals,
1005
+ formatAmount,
1006
+ isNegative,
1007
+ isZero,
1008
+ money,
1009
+ mulRate,
1010
+ negate,
1011
+ parseAmount,
1012
+ subtract,
1013
+ toStep,
1014
+ zero,
1015
+ } from '@forgezero/runtime/finance/money';
1016
+
1017
+ import type {
1018
+ AssetSpec,
1019
+ Money,
1020
+ Rounding,
1021
+ } from '@forgezero/runtime/finance/money';
1022
+ ```
1023
+
1024
+ ## @forgezero/runtime/finance/money — Use this entry point
1025
+
1026
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
401
1027
 
402
1028
  ```text
403
- import { ASSETS, MoneyError, ROUNDING, VERSION, abs, add } from '@forgezero/runtime/finance/money';
404
- import { allocate, assetSpec, compare, convert, defineAsset, equals } from '@forgezero/runtime/finance/money';
405
- import { formatAmount, isNegative, isZero, money, mulRate, negate } from '@forgezero/runtime/finance/money';
406
- import { parseAmount, subtract, toStep, zero } from '@forgezero/runtime/finance/money';
407
- import type { AssetSpec, Money, Rounding } from '@forgezero/runtime/finance/money';
1029
+ import {
1030
+ ASSETS,
1031
+ } from '@forgezero/runtime/finance/money';
1032
+
1033
+ export const selectedCapability = ASSETS;
408
1034
  ```
409
1035
 
410
1036
  <a id="forgezero-runtime-finance-venues"></a>
411
1037
  ## @forgezero/runtime/finance/venues
412
1038
 
413
- Trading venues, market types and symbols as data — spot, margin and futures behind one order model. Named value imports: MARKET_TYPES, ORDER_SIDES, ORDER_TYPES, TIME_IN_FORCE, VENUES, VERSION, VenueError, notionalOf, parseSymbol, submitOrder, symbolOf, validateOrder, venue, venuesFor. Named type imports: MarketSpec, MarketType, OrderRequest, OrderResult, OrderSide, OrderStatus, OrderType, TimeInForce, VenueAdapter, VenueSpec. Import only the names used by this file.
1039
+ Trading venues, market types and symbols as data — spot, margin and futures behind one order model. This entry exposes 14 named value exports and 10 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
414
1040
 
415
1041
  ```text
416
- import { MARKET_TYPES, ORDER_SIDES, ORDER_TYPES, TIME_IN_FORCE, VENUES, VERSION } from '@forgezero/runtime/finance/venues';
417
- import { VenueError, notionalOf, parseSymbol, submitOrder, symbolOf, validateOrder } from '@forgezero/runtime/finance/venues';
418
- import { venue, venuesFor } from '@forgezero/runtime/finance/venues';
419
- import type { MarketSpec, MarketType, OrderRequest, OrderResult, OrderSide, OrderStatus } from '@forgezero/runtime/finance/venues';
420
- import type { OrderType, TimeInForce, VenueAdapter, VenueSpec } from '@forgezero/runtime/finance/venues';
1042
+ import {
1043
+ MARKET_TYPES,
1044
+ ORDER_SIDES,
1045
+ ORDER_TYPES,
1046
+ TIME_IN_FORCE,
1047
+ VENUES,
1048
+ VERSION,
1049
+ VenueError,
1050
+ notionalOf,
1051
+ parseSymbol,
1052
+ submitOrder,
1053
+ symbolOf,
1054
+ validateOrder,
1055
+ venue,
1056
+ venuesFor,
1057
+ } from '@forgezero/runtime/finance/venues';
1058
+
1059
+ import type {
1060
+ MarketSpec,
1061
+ MarketType,
1062
+ OrderRequest,
1063
+ OrderResult,
1064
+ OrderSide,
1065
+ OrderStatus,
1066
+ OrderType,
1067
+ TimeInForce,
1068
+ VenueAdapter,
1069
+ VenueSpec,
1070
+ } from '@forgezero/runtime/finance/venues';
1071
+ ```
1072
+
1073
+ ## @forgezero/runtime/finance/venues — Use this entry point
1074
+
1075
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
1076
+
1077
+ ```text
1078
+ import {
1079
+ MARKET_TYPES,
1080
+ } from '@forgezero/runtime/finance/venues';
1081
+
1082
+ export const selectedCapability = MARKET_TYPES;
421
1083
  ```
422
1084
 
423
1085
  <a id="forgezero-runtime-finance-ledger"></a>
424
1086
  ## @forgezero/runtime/finance/ledger
425
1087
 
426
- Double-entry postings and derived balances. A hold is a posting, not a lock — the queue does the ordering. Named value imports: ACCOUNT_KINDS, BUCKETS, LedgerError, MAX_LEDGER_ENTRIES, VERSION, accountId, assertAvailable, assertBalanced, availableOf, balanceOf, balancesFrom, captureHold, heldOf, parseAccount, placeHold, queueKeyFor, releaseHold, statement, totalOf, transfer, trialBalance. Named type imports: AccountKind, AccountRef, Bucket, Entry, Transaction, TrialBalance. Import only the names used by this file.
1088
+ Double-entry postings and derived balances. A hold is a posting, not a lock — the queue does the ordering. This entry exposes 21 named value exports and 6 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
1089
+
1090
+ ```text
1091
+ import {
1092
+ ACCOUNT_KINDS,
1093
+ BUCKETS,
1094
+ LedgerError,
1095
+ MAX_LEDGER_ENTRIES,
1096
+ VERSION,
1097
+ accountId,
1098
+ assertAvailable,
1099
+ assertBalanced,
1100
+ availableOf,
1101
+ balanceOf,
1102
+ balancesFrom,
1103
+ captureHold,
1104
+ heldOf,
1105
+ parseAccount,
1106
+ placeHold,
1107
+ queueKeyFor,
1108
+ releaseHold,
1109
+ statement,
1110
+ totalOf,
1111
+ transfer,
1112
+ trialBalance,
1113
+ } from '@forgezero/runtime/finance/ledger';
1114
+
1115
+ import type {
1116
+ AccountKind,
1117
+ AccountRef,
1118
+ Bucket,
1119
+ Entry,
1120
+ Transaction,
1121
+ TrialBalance,
1122
+ } from '@forgezero/runtime/finance/ledger';
1123
+ ```
1124
+
1125
+ ## @forgezero/runtime/finance/ledger — Use this entry point
1126
+
1127
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
427
1128
 
428
1129
  ```text
429
- import { ACCOUNT_KINDS, BUCKETS, LedgerError, MAX_LEDGER_ENTRIES, VERSION, accountId } from '@forgezero/runtime/finance/ledger';
430
- import { assertAvailable, assertBalanced, availableOf, balanceOf, balancesFrom, captureHold } from '@forgezero/runtime/finance/ledger';
431
- import { heldOf, parseAccount, placeHold, queueKeyFor, releaseHold, statement } from '@forgezero/runtime/finance/ledger';
432
- import { totalOf, transfer, trialBalance } from '@forgezero/runtime/finance/ledger';
433
- import type { AccountKind, AccountRef, Bucket, Entry, Transaction, TrialBalance } from '@forgezero/runtime/finance/ledger';
1130
+ import {
1131
+ ACCOUNT_KINDS,
1132
+ } from '@forgezero/runtime/finance/ledger';
1133
+
1134
+ export const selectedCapability = ACCOUNT_KINDS;
434
1135
  ```
435
1136
 
436
1137
  <a id="forgezero-runtime-finance-commission"></a>
437
1138
  ## @forgezero/runtime/finance/commission
438
1139
 
439
- Profit net of flows, a high-water mark, the tier split and the referral share of our income. Named value imports: CommissionError, allocate, chargeableProfit, commissionTransaction, nextHighWaterMark, periodProfit, projectPrepay, splitCommission, splitReferrals. Named type imports: CommissionInput, CommissionSplit, PeriodPerformance, Prepay, PrepayInput, ReferralShare. Import only the names used by this file.
1140
+ Profit net of flows, a high-water mark, the tier split and the referral share of our income. This entry exposes 9 named value exports and 6 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
440
1141
 
441
1142
  ```text
442
- import { CommissionError, allocate, chargeableProfit, commissionTransaction, nextHighWaterMark, periodProfit } from '@forgezero/runtime/finance/commission';
443
- import { projectPrepay, splitCommission, splitReferrals } from '@forgezero/runtime/finance/commission';
444
- import type { CommissionInput, CommissionSplit, PeriodPerformance, Prepay, PrepayInput, ReferralShare } from '@forgezero/runtime/finance/commission';
1143
+ import {
1144
+ CommissionError,
1145
+ allocate,
1146
+ chargeableProfit,
1147
+ commissionTransaction,
1148
+ nextHighWaterMark,
1149
+ periodProfit,
1150
+ projectPrepay,
1151
+ splitCommission,
1152
+ splitReferrals,
1153
+ } from '@forgezero/runtime/finance/commission';
1154
+
1155
+ import type {
1156
+ CommissionInput,
1157
+ CommissionSplit,
1158
+ PeriodPerformance,
1159
+ Prepay,
1160
+ PrepayInput,
1161
+ ReferralShare,
1162
+ } from '@forgezero/runtime/finance/commission';
1163
+ ```
1164
+
1165
+ ## @forgezero/runtime/finance/commission — Use this entry point
1166
+
1167
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
1168
+
1169
+ ```text
1170
+ import {
1171
+ CommissionError,
1172
+ } from '@forgezero/runtime/finance/commission';
1173
+
1174
+ export const selectedCapability = CommissionError;
445
1175
  ```
446
1176
 
447
1177
  <a id="forgezero-runtime-finance-rates"></a>
448
1178
  ## @forgezero/runtime/finance/rates
449
1179
 
450
- What an asset is worth in USD, and how old that answer is. A peg never ages; a quote always does. Named value imports: BASE_ASSET, RATE_SOURCES, RateError, assertRate, createRateTable, describeRate, isRegistered, peg, rateRefreshJob, refreshRates, registerAsset. Named type imports: AssetEntry, AssetRate, RateFetcher, RateSource, RateTable, RateTableOptions, RefreshReport. Import only the names used by this file.
1180
+ What an asset is worth in USD, and how old that answer is. A peg never ages; a quote always does. This entry exposes 11 named value exports and 7 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
451
1181
 
452
1182
  ```text
453
- import { BASE_ASSET, RATE_SOURCES, RateError, assertRate, createRateTable, describeRate } from '@forgezero/runtime/finance/rates';
454
- import { isRegistered, peg, rateRefreshJob, refreshRates, registerAsset } from '@forgezero/runtime/finance/rates';
455
- import type { AssetEntry, AssetRate, RateFetcher, RateSource, RateTable, RateTableOptions } from '@forgezero/runtime/finance/rates';
456
- import type { RefreshReport } from '@forgezero/runtime/finance/rates';
1183
+ import {
1184
+ BASE_ASSET,
1185
+ RATE_SOURCES,
1186
+ RateError,
1187
+ assertRate,
1188
+ createRateTable,
1189
+ describeRate,
1190
+ isRegistered,
1191
+ peg,
1192
+ rateRefreshJob,
1193
+ refreshRates,
1194
+ registerAsset,
1195
+ } from '@forgezero/runtime/finance/rates';
1196
+
1197
+ import type {
1198
+ AssetEntry,
1199
+ AssetRate,
1200
+ RateFetcher,
1201
+ RateSource,
1202
+ RateTable,
1203
+ RateTableOptions,
1204
+ RefreshReport,
1205
+ } from '@forgezero/runtime/finance/rates';
1206
+ ```
1207
+
1208
+ ## @forgezero/runtime/finance/rates — Use this entry point
1209
+
1210
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
1211
+
1212
+ ```text
1213
+ import {
1214
+ BASE_ASSET,
1215
+ } from '@forgezero/runtime/finance/rates';
1216
+
1217
+ export const selectedCapability = BASE_ASSET;
457
1218
  ```
458
1219
 
459
1220
  <a id="forgezero-runtime-finance-transfers"></a>
460
1221
  ## @forgezero/runtime/finance/transfers
461
1222
 
462
- Deposits and withdrawals as ordered pipelines, with screening reserved at position zero. Named value imports: DIRECTIONS, PipelineError, SCREENING_ORDER, approvalStage, balanceStage, createTransferPipeline, limitsStage, notFrozenStage, screeningStage. Named type imports: Direction, PipelineResult, Stage, StageOutcome, Transfer, TransferPipeline. Import only the names used by this file.
1223
+ Deposits and withdrawals as ordered pipelines, with screening reserved at position zero. This entry exposes 9 named value exports and 6 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
1224
+
1225
+ ```text
1226
+ import {
1227
+ DIRECTIONS,
1228
+ PipelineError,
1229
+ SCREENING_ORDER,
1230
+ approvalStage,
1231
+ balanceStage,
1232
+ createTransferPipeline,
1233
+ limitsStage,
1234
+ notFrozenStage,
1235
+ screeningStage,
1236
+ } from '@forgezero/runtime/finance/transfers';
1237
+
1238
+ import type {
1239
+ Direction,
1240
+ PipelineResult,
1241
+ Stage,
1242
+ StageOutcome,
1243
+ Transfer,
1244
+ TransferPipeline,
1245
+ } from '@forgezero/runtime/finance/transfers';
1246
+ ```
1247
+
1248
+ ## @forgezero/runtime/finance/transfers — Use this entry point
1249
+
1250
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
463
1251
 
464
1252
  ```text
465
- import { DIRECTIONS, PipelineError, SCREENING_ORDER, approvalStage, balanceStage, createTransferPipeline } from '@forgezero/runtime/finance/transfers';
466
- import { limitsStage, notFrozenStage, screeningStage } from '@forgezero/runtime/finance/transfers';
467
- import type { Direction, PipelineResult, Stage, StageOutcome, Transfer, TransferPipeline } from '@forgezero/runtime/finance/transfers';
1253
+ import {
1254
+ DIRECTIONS,
1255
+ } from '@forgezero/runtime/finance/transfers';
1256
+
1257
+ export const selectedCapability = DIRECTIONS;
468
1258
  ```
469
1259
 
470
1260
  <a id="forgezero-runtime-finance-chain"></a>
471
1261
  ## @forgezero/runtime/finance/chain
472
1262
 
473
- Which chains exist, their confirmation depth by value band, assets and explorers — as data an admin edits. Named value imports: ADDRESS_SCHEMES, ChainError, SEED_CHAINS, SEED_CHAIN_ASSETS, assertChain, confirmationsFor, createChainRegistry, estimatedSeconds, validateAddress. Named type imports: AddressScheme, ChainAsset, ChainRegistry, ChainSpec, ConfirmationBand. Import only the names used by this file.
1263
+ Which chains exist, their confirmation depth by value band, assets and explorers — as data an admin edits. This entry exposes 9 named value exports and 5 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
1264
+
1265
+ ```text
1266
+ import {
1267
+ ADDRESS_SCHEMES,
1268
+ ChainError,
1269
+ SEED_CHAINS,
1270
+ SEED_CHAIN_ASSETS,
1271
+ assertChain,
1272
+ confirmationsFor,
1273
+ createChainRegistry,
1274
+ estimatedSeconds,
1275
+ validateAddress,
1276
+ } from '@forgezero/runtime/finance/chain';
1277
+
1278
+ import type {
1279
+ AddressScheme,
1280
+ ChainAsset,
1281
+ ChainRegistry,
1282
+ ChainSpec,
1283
+ ConfirmationBand,
1284
+ } from '@forgezero/runtime/finance/chain';
1285
+ ```
1286
+
1287
+ ## @forgezero/runtime/finance/chain — Use this entry point
1288
+
1289
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
474
1290
 
475
1291
  ```text
476
- import { ADDRESS_SCHEMES, ChainError, SEED_CHAINS, SEED_CHAIN_ASSETS, assertChain, confirmationsFor } from '@forgezero/runtime/finance/chain';
477
- import { createChainRegistry, estimatedSeconds, validateAddress } from '@forgezero/runtime/finance/chain';
478
- import type { AddressScheme, ChainAsset, ChainRegistry, ChainSpec, ConfirmationBand } from '@forgezero/runtime/finance/chain';
1292
+ import {
1293
+ ADDRESS_SCHEMES,
1294
+ } from '@forgezero/runtime/finance/chain';
1295
+
1296
+ export const selectedCapability = ADDRESS_SCHEMES;
479
1297
  ```
480
1298
 
481
1299
  <a id="forgezero-runtime-finance-custody"></a>
482
1300
  ## @forgezero/runtime/finance/custody
483
1301
 
484
- Derive CREATE2 deposit addresses and EIP-712 custody digests — arithmetic over a seed and a salt, needing no credential and no node. Named value imports: CustodyError, VERSION, depositAddress, domainSeparator, orderSignatures, saltFor, toChecksumAddress, withdrawDigest. Named type imports: none. Import only the names used by this file.
1302
+ Derive CREATE2 deposit addresses and EIP-712 custody digests — arithmetic over a seed and a salt, needing no credential and no node. This entry exposes 8 named value exports and 0 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
485
1303
 
486
1304
  ```text
487
- import { CustodyError, VERSION, depositAddress, domainSeparator, orderSignatures, saltFor } from '@forgezero/runtime/finance/custody';
488
- import { toChecksumAddress, withdrawDigest } from '@forgezero/runtime/finance/custody';
1305
+ import {
1306
+ CustodyError,
1307
+ VERSION,
1308
+ depositAddress,
1309
+ domainSeparator,
1310
+ orderSignatures,
1311
+ saltFor,
1312
+ toChecksumAddress,
1313
+ withdrawDigest,
1314
+ } from '@forgezero/runtime/finance/custody';
1315
+ ```
1316
+
1317
+ ## @forgezero/runtime/finance/custody — Use this entry point
1318
+
1319
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
1320
+
1321
+ ```text
1322
+ import {
1323
+ CustodyError,
1324
+ } from '@forgezero/runtime/finance/custody';
1325
+
1326
+ export const selectedCapability = CustodyError;
489
1327
  ```
490
1328
 
491
1329
  <a id="forgezero-runtime-finance-derive"></a>
492
1330
  ## @forgezero/runtime/finance/derive
493
1331
 
494
- Declare a field ForgeZero generates rather than the tenant supplying: BIP-44 path arithmetic, and the choice of who is capable of generating the key. Named value imports: CUSTODY, DERIVE_KEYWORD, DeriveError, SCHEMES, assertDeriveSpec, custodyOf, deriveSpecOf, derivedFields, derivedPaths, pathFor, suppliedPaths. Named type imports: Custody, DeriveSpec, DerivedField, Scheme. Import only the names used by this file.
1332
+ Declare a field ForgeZero generates rather than the tenant supplying: BIP-44 path arithmetic, and the choice of who is capable of generating the key. This entry exposes 11 named value exports and 4 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
495
1333
 
496
1334
  ```text
497
- import { CUSTODY, DERIVE_KEYWORD, DeriveError, SCHEMES, assertDeriveSpec, custodyOf } from '@forgezero/runtime/finance/derive';
498
- import { deriveSpecOf, derivedFields, derivedPaths, pathFor, suppliedPaths } from '@forgezero/runtime/finance/derive';
499
- import type { Custody, DeriveSpec, DerivedField, Scheme } from '@forgezero/runtime/finance/derive';
1335
+ import {
1336
+ CUSTODY,
1337
+ DERIVE_KEYWORD,
1338
+ DeriveError,
1339
+ SCHEMES,
1340
+ assertDeriveSpec,
1341
+ custodyOf,
1342
+ deriveSpecOf,
1343
+ derivedFields,
1344
+ derivedPaths,
1345
+ pathFor,
1346
+ suppliedPaths,
1347
+ } from '@forgezero/runtime/finance/derive';
1348
+
1349
+ import type {
1350
+ Custody,
1351
+ DeriveSpec,
1352
+ DerivedField,
1353
+ Scheme,
1354
+ } from '@forgezero/runtime/finance/derive';
1355
+ ```
1356
+
1357
+ ## @forgezero/runtime/finance/derive — Use this entry point
1358
+
1359
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
1360
+
1361
+ ```text
1362
+ import {
1363
+ CUSTODY,
1364
+ } from '@forgezero/runtime/finance/derive';
1365
+
1366
+ export const selectedCapability = CUSTODY;
500
1367
  ```
501
1368
 
502
1369
  <a id="forgezero-runtime-finance-tax"></a>
503
1370
  ## @forgezero/runtime/finance/tax
504
1371
 
505
- Which jurisdiction may tax a sale, who accounts for it, and the three ways to be zero that report differently. Rates are data. Named value imports: TREATMENTS, TaxError, applyTax, assertTaxRate, decideTax, describeTax, parseRate, percent, totalWithTax. Named type imports: Customer, Supplier, TaxAmounts, TaxDecision, TaxRate, Treatment. Import only the names used by this file.
1372
+ Which jurisdiction may tax a sale, who accounts for it, and the three ways to be zero that report differently. Rates are data. This entry exposes 9 named value exports and 6 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
1373
+
1374
+ ```text
1375
+ import {
1376
+ TREATMENTS,
1377
+ TaxError,
1378
+ applyTax,
1379
+ assertTaxRate,
1380
+ decideTax,
1381
+ describeTax,
1382
+ parseRate,
1383
+ percent,
1384
+ totalWithTax,
1385
+ } from '@forgezero/runtime/finance/tax';
1386
+
1387
+ import type {
1388
+ Customer,
1389
+ Supplier,
1390
+ TaxAmounts,
1391
+ TaxDecision,
1392
+ TaxRate,
1393
+ Treatment,
1394
+ } from '@forgezero/runtime/finance/tax';
1395
+ ```
1396
+
1397
+ ## @forgezero/runtime/finance/tax — Use this entry point
1398
+
1399
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
506
1400
 
507
1401
  ```text
508
- import { TREATMENTS, TaxError, applyTax, assertTaxRate, decideTax, describeTax } from '@forgezero/runtime/finance/tax';
509
- import { parseRate, percent, totalWithTax } from '@forgezero/runtime/finance/tax';
510
- import type { Customer, Supplier, TaxAmounts, TaxDecision, TaxRate, Treatment } from '@forgezero/runtime/finance/tax';
1402
+ import {
1403
+ TREATMENTS,
1404
+ } from '@forgezero/runtime/finance/tax';
1405
+
1406
+ export const selectedCapability = TREATMENTS;
511
1407
  ```
512
1408
 
513
1409
  <a id="forgezero-runtime-finance-storage"></a>
514
1410
  ## @forgezero/runtime/finance/storage
515
1411
 
516
- Write an amount so it is both exact and sortable: an authoritative string, and a number that is only an index. Named value imports: SORT_FIELD, fromStored, rangeBounds, sortExact, sortKey, storeAmount, toStored, withinRange. Named type imports: StoredMoney. Import only the names used by this file.
1412
+ Write an amount so it is both exact and sortable: an authoritative string, and a number that is only an index. This entry exposes 8 named value exports and 1 named type export. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
1413
+
1414
+ ```text
1415
+ import {
1416
+ SORT_FIELD,
1417
+ fromStored,
1418
+ rangeBounds,
1419
+ sortExact,
1420
+ sortKey,
1421
+ storeAmount,
1422
+ toStored,
1423
+ withinRange,
1424
+ } from '@forgezero/runtime/finance/storage';
1425
+
1426
+ import type {
1427
+ StoredMoney,
1428
+ } from '@forgezero/runtime/finance/storage';
1429
+ ```
1430
+
1431
+ ## @forgezero/runtime/finance/storage — Use this entry point
1432
+
1433
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
517
1434
 
518
1435
  ```text
519
- import { SORT_FIELD, fromStored, rangeBounds, sortExact, sortKey, storeAmount } from '@forgezero/runtime/finance/storage';
520
- import { toStored, withinRange } from '@forgezero/runtime/finance/storage';
521
- import type { StoredMoney } from '@forgezero/runtime/finance/storage';
1436
+ import {
1437
+ SORT_FIELD,
1438
+ } from '@forgezero/runtime/finance/storage';
1439
+
1440
+ export const selectedCapability = SORT_FIELD;
522
1441
  ```
523
1442
 
524
1443
  <a id="forgezero-runtime-realtime"></a>
525
1444
  ## @forgezero/runtime/realtime
526
1445
 
527
- Provider-neutral realtime audience, shard, event and delivery contracts. Named value imports: REALTIME_MAX_BATCH_BYTES, REALTIME_MAX_EVENTS, REALTIME_MAX_EVENT_BYTES, REALTIME_MAX_SHARDS_PER_TOPIC, REALTIME_MAX_SOCKETS_PER_SHARD, canReceiveRealtimeAudience, issueRealtimeSubscriptionTicket, realtimeBatchBytes, realtimeHmac, realtimeShardKey, validateRealtimeAudience, validateRealtimeBatch, validateRealtimeSubscriptionTicket, verifyRealtimeHmac, verifyRealtimeSubscriptionToken. Named type imports: RealtimeAudience, RealtimeBatch, RealtimeEvent, RealtimePrincipalKind, RealtimeSubscriptionTicket. Import only the names used by this file.
1446
+ Provider-neutral realtime audience, shard, event and delivery contracts. This entry exposes 15 named value exports and 5 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
528
1447
 
529
1448
  ```text
530
- import { REALTIME_MAX_BATCH_BYTES, REALTIME_MAX_EVENTS, REALTIME_MAX_EVENT_BYTES, REALTIME_MAX_SHARDS_PER_TOPIC, REALTIME_MAX_SOCKETS_PER_SHARD, canReceiveRealtimeAudience } from '@forgezero/runtime/realtime';
531
- import { issueRealtimeSubscriptionTicket, realtimeBatchBytes, realtimeHmac, realtimeShardKey, validateRealtimeAudience, validateRealtimeBatch } from '@forgezero/runtime/realtime';
532
- import { validateRealtimeSubscriptionTicket, verifyRealtimeHmac, verifyRealtimeSubscriptionToken } from '@forgezero/runtime/realtime';
533
- import type { RealtimeAudience, RealtimeBatch, RealtimeEvent, RealtimePrincipalKind, RealtimeSubscriptionTicket } from '@forgezero/runtime/realtime';
1449
+ import {
1450
+ REALTIME_MAX_BATCH_BYTES,
1451
+ REALTIME_MAX_EVENTS,
1452
+ REALTIME_MAX_EVENT_BYTES,
1453
+ REALTIME_MAX_SHARDS_PER_TOPIC,
1454
+ REALTIME_MAX_SOCKETS_PER_SHARD,
1455
+ canReceiveRealtimeAudience,
1456
+ issueRealtimeSubscriptionTicket,
1457
+ realtimeBatchBytes,
1458
+ realtimeHmac,
1459
+ realtimeShardKey,
1460
+ validateRealtimeAudience,
1461
+ validateRealtimeBatch,
1462
+ validateRealtimeSubscriptionTicket,
1463
+ verifyRealtimeHmac,
1464
+ verifyRealtimeSubscriptionToken,
1465
+ } from '@forgezero/runtime/realtime';
1466
+
1467
+ import type {
1468
+ RealtimeAudience,
1469
+ RealtimeBatch,
1470
+ RealtimeEvent,
1471
+ RealtimePrincipalKind,
1472
+ RealtimeSubscriptionTicket,
1473
+ } from '@forgezero/runtime/realtime';
1474
+ ```
1475
+
1476
+ ## @forgezero/runtime/realtime — Use this entry point
1477
+
1478
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
1479
+
1480
+ ```text
1481
+ import {
1482
+ REALTIME_MAX_BATCH_BYTES,
1483
+ } from '@forgezero/runtime/realtime';
1484
+
1485
+ export const selectedCapability = REALTIME_MAX_BATCH_BYTES;
534
1486
  ```
535
1487
 
536
1488
  <a id="forgezero-runtime-passkey-hybrid"></a>
537
1489
  ## @forgezero/runtime/passkey-hybrid
538
1490
 
539
- Versioned WebAuthn PRF plus ML-DSA companion proof construction and verification. Named value imports: PASSKEY_HYBRID_SUITE, PASSKEY_HYBRID_VERSION, PASSKEY_ML_DSA_PUBLIC_KEY_BYTES, PASSKEY_ML_DSA_SIGNATURE_BYTES, PASSKEY_PRF_SALT, createPasskeyHybridProof, passkeyHybridMessage, verifyPasskeyHybridProof. Named type imports: PasskeyHybridBinding, PasskeyHybridProof, PasskeyHybridPurpose, PasskeyHybridRegistrationProof. Import only the names used by this file.
1491
+ Versioned WebAuthn PRF plus ML-DSA companion proof construction and verification. This entry exposes 8 named value exports and 4 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
540
1492
 
541
1493
  ```text
542
- import { PASSKEY_HYBRID_SUITE, PASSKEY_HYBRID_VERSION, PASSKEY_ML_DSA_PUBLIC_KEY_BYTES, PASSKEY_ML_DSA_SIGNATURE_BYTES, PASSKEY_PRF_SALT, createPasskeyHybridProof } from '@forgezero/runtime/passkey-hybrid';
543
- import { passkeyHybridMessage, verifyPasskeyHybridProof } from '@forgezero/runtime/passkey-hybrid';
544
- import type { PasskeyHybridBinding, PasskeyHybridProof, PasskeyHybridPurpose, PasskeyHybridRegistrationProof } from '@forgezero/runtime/passkey-hybrid';
1494
+ import {
1495
+ PASSKEY_HYBRID_SUITE,
1496
+ PASSKEY_HYBRID_VERSION,
1497
+ PASSKEY_ML_DSA_PUBLIC_KEY_BYTES,
1498
+ PASSKEY_ML_DSA_SIGNATURE_BYTES,
1499
+ PASSKEY_PRF_SALT,
1500
+ createPasskeyHybridProof,
1501
+ passkeyHybridMessage,
1502
+ verifyPasskeyHybridProof,
1503
+ } from '@forgezero/runtime/passkey-hybrid';
1504
+
1505
+ import type {
1506
+ PasskeyHybridBinding,
1507
+ PasskeyHybridProof,
1508
+ PasskeyHybridPurpose,
1509
+ PasskeyHybridRegistrationProof,
1510
+ } from '@forgezero/runtime/passkey-hybrid';
1511
+ ```
1512
+
1513
+ ## @forgezero/runtime/passkey-hybrid — Use this entry point
1514
+
1515
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
1516
+
1517
+ ```text
1518
+ import {
1519
+ PASSKEY_HYBRID_SUITE,
1520
+ } from '@forgezero/runtime/passkey-hybrid';
1521
+
1522
+ export const selectedCapability = PASSKEY_HYBRID_SUITE;
545
1523
  ```
546
1524
 
547
1525
  <a id="forgezero-runtime-otpauth"></a>
548
1526
  ## @forgezero/runtime/otpauth
549
1527
 
550
- Parse and render otpauth URIs without binding enrolment to a UI framework. Named value imports: formatOtpAuth, fromManualSecret, newOtpAuth, parseOtpAuth. Named type imports: OtpAuth. Import only the names used by this file.
1528
+ Parse and render otpauth URIs without binding enrolment to a UI framework. This entry exposes 4 named value exports and 1 named type export. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
1529
+
1530
+ ```text
1531
+ import {
1532
+ formatOtpAuth,
1533
+ fromManualSecret,
1534
+ newOtpAuth,
1535
+ parseOtpAuth,
1536
+ } from '@forgezero/runtime/otpauth';
1537
+
1538
+ import type {
1539
+ OtpAuth,
1540
+ } from '@forgezero/runtime/otpauth';
1541
+ ```
1542
+
1543
+ ## @forgezero/runtime/otpauth — Use this entry point
1544
+
1545
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
551
1546
 
552
1547
  ```text
553
- import { formatOtpAuth, fromManualSecret, newOtpAuth, parseOtpAuth } from '@forgezero/runtime/otpauth';
554
- import type { OtpAuth } from '@forgezero/runtime/otpauth';
1548
+ import {
1549
+ formatOtpAuth,
1550
+ } from '@forgezero/runtime/otpauth';
1551
+
1552
+ export const selectedCapability = formatOtpAuth;
555
1553
  ```
556
1554
 
557
1555
  <a id="forgezero-runtime-pipeline"></a>
558
1556
  ## @forgezero/runtime/pipeline
559
1557
 
560
- Typed ordered application-pipeline execution with explicit evidence. Named value imports: GIT_PROVIDERS, PipelineError, parsePush, shouldDeploy, verifyWebhook, webhookPath. Named type imports: DeployTrigger, GitProvider, PushEvent. Import only the names used by this file.
1558
+ Typed ordered application-pipeline execution with explicit evidence. This entry exposes 6 named value exports and 3 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
1559
+
1560
+ ```text
1561
+ import {
1562
+ GIT_PROVIDERS,
1563
+ PipelineError,
1564
+ parsePush,
1565
+ shouldDeploy,
1566
+ verifyWebhook,
1567
+ webhookPath,
1568
+ } from '@forgezero/runtime/pipeline';
1569
+
1570
+ import type {
1571
+ DeployTrigger,
1572
+ GitProvider,
1573
+ PushEvent,
1574
+ } from '@forgezero/runtime/pipeline';
1575
+ ```
1576
+
1577
+ ## @forgezero/runtime/pipeline — Use this entry point
1578
+
1579
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
561
1580
 
562
1581
  ```text
563
- import { GIT_PROVIDERS, PipelineError, parsePush, shouldDeploy, verifyWebhook, webhookPath } from '@forgezero/runtime/pipeline';
564
- import type { DeployTrigger, GitProvider, PushEvent } from '@forgezero/runtime/pipeline';
1582
+ import {
1583
+ GIT_PROVIDERS,
1584
+ } from '@forgezero/runtime/pipeline';
1585
+
1586
+ export const selectedCapability = GIT_PROVIDERS;
565
1587
  ```
566
1588
 
567
1589
  <a id="forgezero-runtime-finance-chain-addresses"></a>
568
1590
  ## @forgezero/runtime/finance/chain-addresses
569
1591
 
570
- Chain-address derivation records and validation independent of a node provider. Named value imports: AddressError, COUNTERFACTUAL_SCHEMES, assertDerivationMatches, create2Address, depositAddressBook, depositSaltFor, deriveDepositAddress, ownerOfAddress, toChecksumAddress, validateAddress. Named type imports: AddressScheme, ChainDeployment. Import only the names used by this file.
1592
+ Chain-address derivation records and validation independent of a node provider. This entry exposes 10 named value exports and 2 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
1593
+
1594
+ ```text
1595
+ import {
1596
+ AddressError,
1597
+ COUNTERFACTUAL_SCHEMES,
1598
+ assertDerivationMatches,
1599
+ create2Address,
1600
+ depositAddressBook,
1601
+ depositSaltFor,
1602
+ deriveDepositAddress,
1603
+ ownerOfAddress,
1604
+ toChecksumAddress,
1605
+ validateAddress,
1606
+ } from '@forgezero/runtime/finance/chain-addresses';
1607
+
1608
+ import type {
1609
+ AddressScheme,
1610
+ ChainDeployment,
1611
+ } from '@forgezero/runtime/finance/chain-addresses';
1612
+ ```
1613
+
1614
+ ## @forgezero/runtime/finance/chain-addresses — Use this entry point
1615
+
1616
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
571
1617
 
572
1618
  ```text
573
- import { AddressError, COUNTERFACTUAL_SCHEMES, assertDerivationMatches, create2Address, depositAddressBook, depositSaltFor } from '@forgezero/runtime/finance/chain-addresses';
574
- import { deriveDepositAddress, ownerOfAddress, toChecksumAddress, validateAddress } from '@forgezero/runtime/finance/chain-addresses';
575
- import type { AddressScheme, ChainDeployment } from '@forgezero/runtime/finance/chain-addresses';
1619
+ import {
1620
+ AddressError,
1621
+ } from '@forgezero/runtime/finance/chain-addresses';
1622
+
1623
+ export const selectedCapability = AddressError;
576
1624
  ```
577
1625
 
578
1626
  <a id="forgezero-runtime-finance-chain-deposits"></a>
579
1627
  ## @forgezero/runtime/finance/chain-deposits
580
1628
 
581
- Provider-neutral deposit observation, confirmation and credit transitions. Named value imports: DepositError, creditDeposit, cursorFrom, depositReference, describeScan, isConfirmed, rescanRange, scanOnce. Named type imports: ChainReader, ChainTransfer, DepositCursor, ScanContext, ScanReport. Import only the names used by this file.
1629
+ Provider-neutral deposit observation, confirmation and credit transitions. This entry exposes 8 named value exports and 5 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
582
1630
 
583
1631
  ```text
584
- import { DepositError, creditDeposit, cursorFrom, depositReference, describeScan, isConfirmed } from '@forgezero/runtime/finance/chain-deposits';
585
- import { rescanRange, scanOnce } from '@forgezero/runtime/finance/chain-deposits';
586
- import type { ChainReader, ChainTransfer, DepositCursor, ScanContext, ScanReport } from '@forgezero/runtime/finance/chain-deposits';
1632
+ import {
1633
+ DepositError,
1634
+ creditDeposit,
1635
+ cursorFrom,
1636
+ depositReference,
1637
+ describeScan,
1638
+ isConfirmed,
1639
+ rescanRange,
1640
+ scanOnce,
1641
+ } from '@forgezero/runtime/finance/chain-deposits';
1642
+
1643
+ import type {
1644
+ ChainReader,
1645
+ ChainTransfer,
1646
+ DepositCursor,
1647
+ ScanContext,
1648
+ ScanReport,
1649
+ } from '@forgezero/runtime/finance/chain-deposits';
1650
+ ```
1651
+
1652
+ ## @forgezero/runtime/finance/chain-deposits — Use this entry point
1653
+
1654
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
1655
+
1656
+ ```text
1657
+ import {
1658
+ DepositError,
1659
+ } from '@forgezero/runtime/finance/chain-deposits';
1660
+
1661
+ export const selectedCapability = DepositError;
587
1662
  ```
588
1663
 
589
1664
  <a id="forgezero-runtime-finance-chain-withdrawals"></a>
590
1665
  ## @forgezero/runtime/finance/chain-withdrawals
591
1666
 
592
- Provider-neutral withdrawal approval, broadcast and finality transitions. Named value imports: WITHDRAWAL_STATES, WithdrawalError, approveWithdrawal, broadcastKeyFor, canTransition, confirmWithdrawal, describeSweep, holdReference, markFailed, processOnce, refundFailed, rejectWithdrawal, requestWithdrawal, sweepForPayout. Named type imports: Broadcaster, SweepCandidate, SweepPlan, Withdrawal, WithdrawalState. Import only the names used by this file.
1667
+ Provider-neutral withdrawal approval, broadcast and finality transitions. This entry exposes 14 named value exports and 5 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
593
1668
 
594
1669
  ```text
595
- import { WITHDRAWAL_STATES, WithdrawalError, approveWithdrawal, broadcastKeyFor, canTransition, confirmWithdrawal } from '@forgezero/runtime/finance/chain-withdrawals';
596
- import { describeSweep, holdReference, markFailed, processOnce, refundFailed, rejectWithdrawal } from '@forgezero/runtime/finance/chain-withdrawals';
597
- import { requestWithdrawal, sweepForPayout } from '@forgezero/runtime/finance/chain-withdrawals';
598
- import type { Broadcaster, SweepCandidate, SweepPlan, Withdrawal, WithdrawalState } from '@forgezero/runtime/finance/chain-withdrawals';
1670
+ import {
1671
+ WITHDRAWAL_STATES,
1672
+ WithdrawalError,
1673
+ approveWithdrawal,
1674
+ broadcastKeyFor,
1675
+ canTransition,
1676
+ confirmWithdrawal,
1677
+ describeSweep,
1678
+ holdReference,
1679
+ markFailed,
1680
+ processOnce,
1681
+ refundFailed,
1682
+ rejectWithdrawal,
1683
+ requestWithdrawal,
1684
+ sweepForPayout,
1685
+ } from '@forgezero/runtime/finance/chain-withdrawals';
1686
+
1687
+ import type {
1688
+ Broadcaster,
1689
+ SweepCandidate,
1690
+ SweepPlan,
1691
+ Withdrawal,
1692
+ WithdrawalState,
1693
+ } from '@forgezero/runtime/finance/chain-withdrawals';
1694
+ ```
1695
+
1696
+ ## @forgezero/runtime/finance/chain-withdrawals — Use this entry point
1697
+
1698
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
1699
+
1700
+ ```text
1701
+ import {
1702
+ WITHDRAWAL_STATES,
1703
+ } from '@forgezero/runtime/finance/chain-withdrawals';
1704
+
1705
+ export const selectedCapability = WITHDRAWAL_STATES;
599
1706
  ```
600
1707
 
601
1708
  <a id="forgezero-runtime-finance-chain-reconcile"></a>
602
1709
  ## @forgezero/runtime/finance/chain-reconcile
603
1710
 
604
- Deterministic reconciliation between chain observations and durable transfer state. Named value imports: DISCREPANCY_KINDS, ReconcileError, reconcileOnce, reconcileReport, shortfallUsd. Named type imports: Discrepancy, DiscrepancyKind, LedgerLiability, OnChainHolding, ReconcileReport. Import only the names used by this file.
1711
+ Deterministic reconciliation between chain observations and durable transfer state. This entry exposes 5 named value exports and 5 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
1712
+
1713
+ ```text
1714
+ import {
1715
+ DISCREPANCY_KINDS,
1716
+ ReconcileError,
1717
+ reconcileOnce,
1718
+ reconcileReport,
1719
+ shortfallUsd,
1720
+ } from '@forgezero/runtime/finance/chain-reconcile';
1721
+
1722
+ import type {
1723
+ Discrepancy,
1724
+ DiscrepancyKind,
1725
+ LedgerLiability,
1726
+ OnChainHolding,
1727
+ ReconcileReport,
1728
+ } from '@forgezero/runtime/finance/chain-reconcile';
1729
+ ```
1730
+
1731
+ ## @forgezero/runtime/finance/chain-reconcile — Use this entry point
1732
+
1733
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
605
1734
 
606
1735
  ```text
607
- import { DISCREPANCY_KINDS, ReconcileError, reconcileOnce, reconcileReport, shortfallUsd } from '@forgezero/runtime/finance/chain-reconcile';
608
- import type { Discrepancy, DiscrepancyKind, LedgerLiability, OnChainHolding, ReconcileReport } from '@forgezero/runtime/finance/chain-reconcile';
1736
+ import {
1737
+ DISCREPANCY_KINDS,
1738
+ } from '@forgezero/runtime/finance/chain-reconcile';
1739
+
1740
+ export const selectedCapability = DISCREPANCY_KINDS;
609
1741
  ```
610
1742
 
611
1743
  <a id="forgezero-runtime-finance-market"></a>
612
1744
  ## @forgezero/runtime/finance/market
613
1745
 
614
- Market order, fill and quote contracts independent of any exchange adapter. Named value imports: MarketError, createFeed, disagreementOf, isStale, lastPrice, limitFor, stalenessOf, subscribe. Named type imports: Feed, FeedEvent, FeedOptions, PriceResult, Quote, StalenessPolicy, VenueSource. Import only the names used by this file.
1746
+ Market order, fill and quote contracts independent of any exchange adapter. This entry exposes 8 named value exports and 7 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
615
1747
 
616
1748
  ```text
617
- import { MarketError, createFeed, disagreementOf, isStale, lastPrice, limitFor } from '@forgezero/runtime/finance/market';
618
- import { stalenessOf, subscribe } from '@forgezero/runtime/finance/market';
619
- import type { Feed, FeedEvent, FeedOptions, PriceResult, Quote, StalenessPolicy } from '@forgezero/runtime/finance/market';
620
- import type { VenueSource } from '@forgezero/runtime/finance/market';
1749
+ import {
1750
+ MarketError,
1751
+ createFeed,
1752
+ disagreementOf,
1753
+ isStale,
1754
+ lastPrice,
1755
+ limitFor,
1756
+ stalenessOf,
1757
+ subscribe,
1758
+ } from '@forgezero/runtime/finance/market';
1759
+
1760
+ import type {
1761
+ Feed,
1762
+ FeedEvent,
1763
+ FeedOptions,
1764
+ PriceResult,
1765
+ Quote,
1766
+ StalenessPolicy,
1767
+ VenueSource,
1768
+ } from '@forgezero/runtime/finance/market';
1769
+ ```
1770
+
1771
+ ## @forgezero/runtime/finance/market — Use this entry point
1772
+
1773
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
1774
+
1775
+ ```text
1776
+ import {
1777
+ MarketError,
1778
+ } from '@forgezero/runtime/finance/market';
1779
+
1780
+ export const selectedCapability = MarketError;
621
1781
  ```
622
1782
 
623
1783
  <a id="forgezero-runtime-custody-share"></a>
624
1784
  ## @forgezero/runtime/custody-share
625
1785
 
626
- Threshold-share parsing, validation and reconstruction. Named value imports: PROBE_BYTES, factorWrapAad, joinProbeAndShare, openFactorEnvelope, openSealedToFactor, openShareWithPasskey, openShareWithPhrase, passkeyWrappingKey, phraseWrappingKey, sealShare, shareIndexOf, splitProbeAndShare, wrappingKeysFor. Named type imports: SealedShare, WrappingKeys. Import only the names used by this file.
1786
+ Threshold-share parsing, validation and reconstruction. This entry exposes 13 named value exports and 2 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
627
1787
 
628
1788
  ```text
629
- import { PROBE_BYTES, factorWrapAad, joinProbeAndShare, openFactorEnvelope, openSealedToFactor, openShareWithPasskey } from '@forgezero/runtime/custody-share';
630
- import { openShareWithPhrase, passkeyWrappingKey, phraseWrappingKey, sealShare, shareIndexOf, splitProbeAndShare } from '@forgezero/runtime/custody-share';
631
- import { wrappingKeysFor } from '@forgezero/runtime/custody-share';
632
- import type { SealedShare, WrappingKeys } from '@forgezero/runtime/custody-share';
1789
+ import {
1790
+ PROBE_BYTES,
1791
+ factorWrapAad,
1792
+ joinProbeAndShare,
1793
+ openFactorEnvelope,
1794
+ openSealedToFactor,
1795
+ openShareWithPasskey,
1796
+ openShareWithPhrase,
1797
+ passkeyWrappingKey,
1798
+ phraseWrappingKey,
1799
+ sealShare,
1800
+ shareIndexOf,
1801
+ splitProbeAndShare,
1802
+ wrappingKeysFor,
1803
+ } from '@forgezero/runtime/custody-share';
1804
+
1805
+ import type {
1806
+ SealedShare,
1807
+ WrappingKeys,
1808
+ } from '@forgezero/runtime/custody-share';
1809
+ ```
1810
+
1811
+ ## @forgezero/runtime/custody-share — Use this entry point
1812
+
1813
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
1814
+
1815
+ ```text
1816
+ import {
1817
+ PROBE_BYTES,
1818
+ } from '@forgezero/runtime/custody-share';
1819
+
1820
+ export const selectedCapability = PROBE_BYTES;
633
1821
  ```
634
1822
 
635
1823
  <a id="forgezero-runtime-custody-crypto"></a>
636
1824
  ## @forgezero/runtime/custody-crypto
637
1825
 
638
- Hybrid ML-KEM-768 plus X25519 custody-share sealing and opening. Named value imports: deriveKey, openFromKey, openWithKey, sealToKey, sealWithKey, wrappingKeyPair. Named type imports: CipherBox, SealedToKey. Import only the names used by this file.
1826
+ Hybrid ML-KEM-768 plus X25519 custody-share sealing and opening. This entry exposes 6 named value exports and 2 named type exports. The generated import block lists one name per line for scanning and copying; keep only the names used by your file.
1827
+
1828
+ ```text
1829
+ import {
1830
+ deriveKey,
1831
+ openFromKey,
1832
+ openWithKey,
1833
+ sealToKey,
1834
+ sealWithKey,
1835
+ wrappingKeyPair,
1836
+ } from '@forgezero/runtime/custody-crypto';
1837
+
1838
+ import type {
1839
+ CipherBox,
1840
+ SealedToKey,
1841
+ } from '@forgezero/runtime/custody-crypto';
1842
+ ```
1843
+
1844
+ ## @forgezero/runtime/custody-crypto — Use this entry point
1845
+
1846
+ This minimal executable use imports one concrete value from this exact entry point without a wildcard or package-root detour. Keep the value or values the application actually needs; the full named inventory remains directly above it.
639
1847
 
640
1848
  ```text
641
- import { deriveKey, openFromKey, openWithKey, sealToKey, sealWithKey, wrappingKeyPair } from '@forgezero/runtime/custody-crypto';
642
- import type { CipherBox, SealedToKey } from '@forgezero/runtime/custody-crypto';
1849
+ import {
1850
+ deriveKey,
1851
+ } from '@forgezero/runtime/custody-crypto';
1852
+
1853
+ export const selectedCapability = deriveKey;
643
1854
  ```
644
1855
 
645
1856
  ## 1. Install, then import a subpath
@@ -649,8 +1860,12 @@ There is no root export, and that is deliberate. `import from "@forgezero/runtim
649
1860
  ```text
650
1861
  bun add @forgezero/runtime
651
1862
 
652
- import { parseAmount } from '@forgezero/runtime/finance/money';
653
- import { createScheduler } from '@forgezero/runtime/jobs';
1863
+ import {
1864
+ parseAmount,
1865
+ } from '@forgezero/runtime/finance/money';
1866
+ import {
1867
+ createScheduler,
1868
+ } from '@forgezero/runtime/jobs';
654
1869
 
655
1870
  // This throws. It is supposed to.
656
1871
  // import { anything } from '@forgezero/runtime';
@@ -711,8 +1926,15 @@ bun add @sinclair/typebox
711
1926
  An amount is minor units as a bigint with its asset attached, so two currencies cannot be added by accident and a rounding mode is always stated. A database needs a second thing the bigint cannot give it — an ORDER BY that works — so `finance/storage` writes both: the authoritative string, and a lossy double used for sorting and range filters only. One ETH is 10^18 minor units and a signed 64-bit column overflows at about nine ETH, which is why the exact value is never the sortable one.
712
1927
 
713
1928
  ```text
714
- import { parseAmount, mulRate, formatAmount } from '@forgezero/runtime/finance/money';
715
- import { toStored, rangeBounds } from '@forgezero/runtime/finance/storage';
1929
+ import {
1930
+ parseAmount,
1931
+ mulRate,
1932
+ formatAmount,
1933
+ } from '@forgezero/runtime/finance/money';
1934
+ import {
1935
+ toStored,
1936
+ rangeBounds,
1937
+ } from '@forgezero/runtime/finance/storage';
716
1938
 
717
1939
  const fee = mulRate(parseAmount('1250.00', 'USD'), '0.015', 'down');
718
1940
  formatAmount(fee); // '18.75' — never 18.749999999
@@ -741,7 +1963,11 @@ node_modules/@forgezero/runtime/contracts/src/
741
1963
  The lock and the cursor store are interfaces, so this runs against a database, Redis, or nothing at all in a test.
742
1964
 
743
1965
  ```text
744
- import { createScheduler, defineJob, cursorJob } from '@forgezero/runtime/jobs';
1966
+ import {
1967
+ createScheduler,
1968
+ defineJob,
1969
+ cursorJob,
1970
+ } from '@forgezero/runtime/jobs';
745
1971
  ```
746
1972
 
747
1973
  ## Never setInterval
@@ -811,7 +2037,10 @@ scheduler.status();
811
2037
  TypeBox is a peer dependency and optional. A project on Zod pulls none of it, because the interface is what the other packages depend on.
812
2038
 
813
2039
  ```text
814
- import { validate, describeForm } from '@forgezero/runtime/schema';
2040
+ import {
2041
+ validate,
2042
+ describeForm,
2043
+ } from '@forgezero/runtime/schema';
815
2044
 
816
2045
  // only if you validate with TypeBox
817
2046
  bun add @sinclair/typebox
@@ -822,7 +2051,10 @@ bun add @sinclair/typebox
822
2051
  Query strings are entirely strings, so values are converted before checking — otherwise ?port=587 fails a schema expecting a number on a perfectly well-formed request.
823
2052
 
824
2053
  ```text
825
- import { typebox, T } from '@forgezero/runtime/schema/typebox';
2054
+ import {
2055
+ typebox,
2056
+ T,
2057
+ } from '@forgezero/runtime/schema/typebox';
826
2058
 
827
2059
  const Config = T.Object(
828
2060
  { host: T.String(), port: T.Integer() },