@noy-db/hub 0.3.0-pre.10 → 0.3.0-pre.11

package/dist/via/classified/binding.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The classified `ViaBinding` (#629 Task 5, LIVE since Task 6) — wires
+ * classified-fields declaration/write-enforcement/at-rest sealing/erasure
+ * into the kernel's generic Via port. Mirrors `via/money/binding.ts`'s
+ * inline declaration-time validation and `via/i18n/binding.ts`'s
+ * `linkXVia` static-link pattern — except the link itself is EAGER
+ * (`port/with/classified-strategy.ts` calls `linkClassifiedVia()` at module
+ * load, not lazily from a `classified.*()` preset call): several fixtures
+ * build a raw `ClassifiedFieldSpec` literal without ever calling a preset,
+ * and the binder must be installed before `compileViaBindings` needs it
+ * regardless.
+ *
+ * `compileViaBindings` (`kernel/collection-config.ts`) compiles this binding
+ * in whenever a collection declares `classifiedFields` — money then i18n
+ * then classified, order pinned. `kernel/collection.ts`'s `_putInternal`
+ * runs `enforceClassifiedWrite`'s effect via the pipeline's `enforceWrite`
+ * phase; the codec's `encodeAtRest`/`decodeAtRest` hooks (Task 3's boundary)
+ * replace the inline `sensitiveFields` seal path for any collection this
+ * binding is compiled into.
+ *
+ * `declare` — `classifiedBinding(cfg)` runs `resolveClassifiedFields` +
+ * `guardClassifiedCompat` at CONSTRUCTION time (the same #553 pattern
+ * `moneyBinding`'s `validateMoneyFieldPaths(moneyFields)` call uses) —
+ * mirrors today's "door 1" (`collection-config.ts`'s
+ * `resolveCollectionConfig`). Both may throw `ClassifiedConfigError`.
+ */
+import type { ViaBinding } from '../../kernel/via/index.js';
+import { type ClassifiedEntry } from './resolve.js';
+import { type ClassifiedGuardCtx } from './guards.js';
+/**
+ * One classified per-slot shred/residue verdict — mirrors
+ * `RecordCodec.SealedShredSlot` (`kernel/enclave/record-keys/record-codec.ts`)
+ * byte-for-byte. Duplicated here (not imported) so this binding never
+ * reaches into `kernel/enclave/` (`via-enclave-isolation`, #629) — the
+ * closure that PRODUCES real values of this shape is codec-owned and
+ * injected via {@link ClassifiedViaConfig.classifySealedShred}.
+ */
+export interface ClassifiedShredSlot {
+    readonly field: string;
+    readonly class: 'shreddable' | 'dekResidue' | 'live-shreddable+dekResidue-in-backups';
+}
+/**
+ * Config a classified collection's declarations resolve to — the binding's
+ * construction input. `entries`/`guardCtx` are the raw "door 1" inputs
+ * (`resolveClassifiedFields`/`guardClassifiedCompat`'s own parameters);
+ * `classifySealedShred`/`purgeSealedCekEnvelopes` are OPTIONAL codec/vault-
+ * provided closures for the `erase` hook — undefined in this dormant task
+ * (no caller wires them yet), wired for real in #629 Task 10 ("posture
+ * enforcement — forget + erase hooks live").
+ */
+export interface ClassifiedViaConfig {
+    readonly entries: Record<string, ClassifiedEntry>;
+    readonly collectionName: string;
+    readonly guardCtx: ClassifiedGuardCtx;
+    /**
+     * Codec-provided closure mirroring `RecordCodec.classifySealedShred` —
+     * classifies a live envelope's `_sealed` slots for crypto-shred
+     * completeness (see that method's doc comment for the shreddable/
+     * dekResidue/both-class semantics). `live` is `ViaEraseCtx.live`'s opaque
+     * envelope, passed straight through. NOT `readonly` (#629 Task 10):
+     * `compileViaBindings` builds this cfg before the owning `Collection`'s
+     * `RecordCodec` exists, so `Collection`'s constructor mutates this field
+     * in place once `this.codec` is available — the closure `eraseClassified`
+     * reads is looked up at CALL time, not at binding-construction time, so
+     * the late assignment is picked up correctly.
+     */
+    classifySealedShred?: (live: unknown) => Promise<{
+        readonly slots: readonly ClassifiedShredSlot[];
+    }>;
+    /**
+     * Vault-provided closure that purges every `_sealed_cek/<collection>/<id>/*`
+     * host-delivery envelope for one record (mirrors `rotateRecordCek`'s own
+     * prefix-delete) and returns the count purged. Deliberately left UNWIRED
+     * by `compileViaBindings` (#629 Task 10) — `forget-sealed-erasure.test.ts`
+     * proves this purge is UNCONDITIONAL on `sealRecordToHost` usage alone,
+     * independent of whether `classifiedFields` is declared (a bare
+     * `sensitive: [...]` collection exercises it with no classified binding
+     * at all) — vault.ts keeps owning it directly so that case stays correct.
+     */
+    readonly purgeSealedCekEnvelopes?: (id: string) => Promise<number>;
+}
+export declare function classifiedBinding(cfg: ClassifiedViaConfig): ViaBinding;
+export declare function linkClassifiedVia(): void;

package/dist/via/classified/config-drift.d.ts

@@ -0,0 +1,34 @@
+/**
+ * C-A / R10 config-drift marker I/O — the store side of the guard, kept OUT of
+ * the kernel `Collection` so the always-on kernel surface stays lean. The
+ * kernel holds only the per-handle memoization; these helpers do the actual
+ * persisted-schema read/write (via the persisted-schemas storage seam, lazily
+ * imported so the classified spine tree-shakes).
+ *
+ * Marker semantics: a collection declaring classified digest-only fields writes
+ * an `x-classified` marker into its `_schemas/<collection>` record on the first
+ * classified write. A handle later opened WITHOUT `classifiedFields` (a naive
+ * handle) reads it back and refuses to write — see RecordCodec.encryptRecord's
+ * R10 guard.
+ *
+ * `dek` is typed as the bare `CryptoKey` global rather than `EnclaveKey`
+ * (`kernel/enclave/crypto.ts`'s alias for the same type) — this file lives
+ * under `via/classified/`, which the `via-enclave-isolation`
+ * architecture guard (#629) forbids from importing `kernel/enclave/` at
+ * all, even type-only.
+ *
+ * @module
+ */
+import type { NoydbStore, VdigFieldPolicy } from '../../kernel/types.js';
+/**
+ * Persist the classified marker for a handle's digest-only fields. No-op when
+ * the handle declares none. Idempotent (delegates to `persistClassifiedMarker`).
+ */
+export declare function persistClassifiedMarkerForFields(store: NoydbStore, vault: string, collectionName: string, vdigFields: ReadonlyMap<string, VdigFieldPolicy> | null, dek: CryptoKey): Promise<void>;
+/**
+ * Read a collection's persisted classified marker's declared digest-only field
+ * set (empty when the collection carries no marker). Cross-session drift signal:
+ * the R10 superset guard refuses a handle whose declared classified set does not
+ * cover every field in this set.
+ */
+export declare function readClassifiedMarkerDigestOnly(store: NoydbStore, vault: string, collectionName: string, dek: CryptoKey): Promise<readonly string[]>;

package/dist/via/classified/descriptor.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Classified fields — behavioral sensitive-field descriptors (stage 1).
+ * Design: docs/superpowers/specs/2026-07-04-classified-fields-design.md
+ * Law: open on write, declarative on read — read-side behavior is this
+ * closed vocabulary; there are no read-side callbacks.
+ * @module
+ */
+export type ClassifiedStorage = 'recoverable' | 'never' | 'digest-only';
+export type ClassifiedList = {
+    readonly kind: 'omit';
+} | {
+    readonly kind: 'mask';
+    readonly pattern: string;
+} | {
+    readonly kind: 'rider';
+    readonly rider: string;
+};
+export type ClassifiedRider = (value: unknown) => unknown;
+export interface ClassifiedFieldSpec {
+    readonly _noydbClassified: true;
+    /**
+     * Via port brand marker — lets a `ClassifiedFieldSpec` satisfy the
+     * kernel's opaque `ViaDescriptor` (#629 Task 5). Optional (unlike
+     * `MoneyDescriptor._viaBrand`/`I18nTextDescriptor._viaBrand`, which are
+     * required): every `classified.*()` preset factory stamps it, but the
+     * pre-existing test suite's hand-rolled `ClassifiedFieldSpec` fixtures
+     * (built without going through a preset) predate this field and would
+     * fail to compile if it were mandatory.
+     */
+    readonly _viaBrand?: 'classified';
+    readonly preset: string;
+    readonly storage: ClassifiedStorage;
+    readonly list: ClassifiedList;
+    readonly sensitivity: 'pii' | 'secret';
+    /** Write-time safe projections; companion field name is `<field>_<rider>`. */
+    readonly riders?: Record<string, ClassifiedRider>;
+    /** Write-time validator: error message, or null when valid. */
+    readonly validate?: (value: unknown) => string | null;
+    /** Digest-only verify policy (stage 2). Mode both sides normalize under. */
+    readonly verifyNormalize?: 'password' | 'secret-answer';
+    /** Decorate ok:true verdicts with mustRotate after this many days (I1). */
+    readonly rotateDays?: number;
+    /** Refuse reuse of the last N values on rotate (cap 8, spec Q4). */
+    readonly notLastN?: number;
+    /** Member of the collection's matchGroup (secretAnswer preset). */
+    readonly verifyGroupMember?: true;
+    /**
+     * Opt into a store-visible blind-index (`_bidx`) tag so equal values become
+     * queryable/joinable while staying digest-only. Digest-only knob (R7); gated
+     * behind the collection's `acknowledgeEquatableRisk` door (R8). Equal values
+     * produce equal tags — a partition leak a DEK holder can offline-dictionary
+     * at the PBKDF2 floor. Absent/false ⇒ refused-by-default.
+     */
+    readonly equatable?: true;
+}
+export interface ClassifiedGroup {
+    readonly _noydbClassifiedGroup: true;
+    /** Via port brand marker — see {@link ClassifiedFieldSpec._viaBrand}. */
+    readonly _viaBrand?: 'classified';
+    readonly preset: string;
+    /** member record-field name -> spec (differential per-member policy). */
+    readonly members: Record<string, ClassifiedFieldSpec>;
+}
+export type ClassifiedEntry = ClassifiedFieldSpec | ClassifiedGroup;
+export declare function isClassifiedFieldSpec(x: unknown): x is ClassifiedFieldSpec;
+export declare function isClassifiedGroup(x: unknown): x is ClassifiedGroup;

package/dist/via/classified/errors.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Configuration/write errors for classified fields. @module
+ *
+ * `ClassifiedConfigError` / `ClassifiedRevealError` moved to `kernel/errors.ts`
+ * (stage 2) so `kernel/enclave/classify/*` can throw them without importing
+ * with-*. Re-exported here under the same names so existing import paths
+ * keep working.
+ */
+export { ClassifiedConfigError, ClassifiedRevealError, ClassifiedVerifyError, ClassifiedRotationError } from '../../kernel/errors.js';
+export declare class ClassifiedNeverStoredError extends Error {
+    readonly collection: string;
+    readonly field: string;
+    constructor(collection: string, field: string);
+}
+export declare class ClassifiedValidationError extends Error {
+    readonly collection: string;
+    readonly field: string;
+    constructor(collection: string, field: string, detail: string);
+}

package/dist/via/classified/guards.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Refusal matrix R1-R5 (spec) — ONE guard, run at BOTH doors:
+ * `collection()` config resolution AND `_applyClassifiedFields` (the reconcile
+ * seam), because crdt/conflictPolicy/perRecordKeys are construction-only
+ * while classifiedFields can attach later (C5's lesson). @module
+ */
+import type { ClassifiedFieldSpec } from './descriptor.js';
+export interface ClassifiedGuardCtx {
+    readonly perRecordKeys: boolean;
+    readonly crdt: boolean;
+    readonly hasConflictPolicy: boolean;
+    /** False on plaintext (`encrypt: false`) collections — no vdig/seal path exists. */
+    readonly storeCiphertext: boolean;
+    readonly deterministicFields: ReadonlySet<string> | null;
+    readonly indexedFields: ReadonlySet<string>;
+    readonly textIndexFields: ReadonlySet<string>;
+    readonly vectorSourceFields: ReadonlySet<string>;
+    readonly subjectKeyField: string | undefined;
+    readonly bareSensitiveFields: ReadonlySet<string>;
+    /** Collection-level gate for the `equatable` knob (R8 double door). */
+    readonly acknowledgeEquatableRisk: boolean;
+}
+export declare function guardClassifiedCompat(collection: string, byField: Record<string, ClassifiedFieldSpec>, ctx: ClassifiedGuardCtx): void;

package/dist/via/classified/index.d.ts

@@ -0,0 +1,11 @@
+/** Classified fields barrel — descriptors, presets, resolver, errors (stage 1). @module */
+export type { ClassifiedStorage, ClassifiedList, ClassifiedRider, ClassifiedFieldSpec, ClassifiedGroup, ClassifiedEntry, } from './descriptor.js';
+export { isClassifiedFieldSpec, isClassifiedGroup } from './descriptor.js';
+export { resolveClassifiedFields, type ResolvedClassified } from './resolve.js';
+export { classified } from './presets.js';
+export { luhnCheck } from './validators.js';
+export { enforceClassifiedWrite } from './write.js';
+export { ClassifiedConfigError, ClassifiedNeverStoredError, ClassifiedValidationError, ClassifiedRevealError, ClassifiedVerifyError, ClassifiedRotationError } from './errors.js';
+export { withClassified } from './active.js';
+export { NO_CLASSIFIED, type ClassifiedStrategy, type ClassifiedRevealCtx } from './strategy.js';
+export type { ClassifiedVerdict, ClassifiedVerifyCtx } from './strategy.js';

package/dist/via/classified/presets.d.ts

@@ -0,0 +1,65 @@
+/** The preset catalog (stage 1). Presets are hub-owned; devs get declarative
+ *  knobs, not read-side callbacks (design law D2/D3). @module */
+import type { ClassifiedFieldSpec, ClassifiedGroup } from './descriptor.js';
+export declare const classified: {
+    /** Composite card type. PAN sealed + last4/bin riders; CVC is storage:'never' (PCI-aware). */
+    creditCard(fields: {
+        pan: string;
+        expiry?: string;
+        cvc?: string;
+    }): ClassifiedGroup;
+    birthDate(): ClassifiedFieldSpec;
+    email(): ClassifiedFieldSpec;
+    phone(): ClassifiedFieldSpec;
+    /** Digest-only password: verify-without-reveal; never listed, never revealed.
+     *  Enumeration math is on the caller for low-entropy values — see the
+     *  per-preset docs; the hub ships no rate limiter in this slice (spec §5).
+     *
+     *  @param opts.equatable — emit a store-visible `_bidx` equality tag (enables
+     *  `findByDigest`). Cost band you are accepting:
+     *
+     *  equal values produce equal store-visible tags: anyone with store access
+     *  learns which records share this secret and how many share each value —
+     *  never the value itself. A collection-DEK holder can additionally test
+     *  candidate values offline: the tag's inner digest is PBKDF2-SHA256 (600K),
+     *  which is GPU/ASIC-friendly — an offline attacker runs on the order of
+     *  10⁴–10⁸ guesses/second, so for low-entropy secrets (PINs, casefolded secret
+     *  answers) offline recovery of the equality partition is seconds-to-hours, not
+     *  years. `crypto.subtle` exposes no memory-hard KDF (no scrypt/argon2) and the
+     *  family's no-crypto-deps law forbids adding one, so PBKDF2-SHA256 is the
+     *  hardest primitive available; the iteration count raises the price but does
+     *  not make a low-entropy field safe. The real control for low-entropy fields
+     *  is the DOOR — do not enable `equatable` for them unless the partition being
+     *  learnable is acceptable — not the iteration count. Pre-forget backups retain
+     *  tags. */
+    password(opts?: {
+        minLength?: number;
+        rotateDays?: number;
+        notLastN?: number;
+        equatable?: true;
+    }): ClassifiedFieldSpec;
+    /** Digest-only secret answer: normalized (casefold/trim/collapse), groupable
+     *  into k-of-n matchGroup challenges. Low-entropy by nature — document the
+     *  enumeration math to your users; add app-side rate limiting.
+     *
+     *  @param opts.equatable — emit a store-visible `_bidx` equality tag (enables
+     *  `findByDigest`). Cost band you are accepting:
+     *
+     *  equal values produce equal store-visible tags: anyone with store access
+     *  learns which records share this secret and how many share each value —
+     *  never the value itself. A collection-DEK holder can additionally test
+     *  candidate values offline: the tag's inner digest is PBKDF2-SHA256 (600K),
+     *  which is GPU/ASIC-friendly — an offline attacker runs on the order of
+     *  10⁴–10⁸ guesses/second, so for low-entropy secrets (PINs, casefolded secret
+     *  answers) offline recovery of the equality partition is seconds-to-hours, not
+     *  years. `crypto.subtle` exposes no memory-hard KDF (no scrypt/argon2) and the
+     *  family's no-crypto-deps law forbids adding one, so PBKDF2-SHA256 is the
+     *  hardest primitive available; the iteration count raises the price but does
+     *  not make a low-entropy field safe. The real control for low-entropy fields
+     *  is the DOOR — do not enable `equatable` for them unless the partition being
+     *  learnable is acceptable — not the iteration count. Pre-forget backups retain
+     *  tags. */
+    secretAnswer(opts?: {
+        equatable?: true;
+    }): ClassifiedFieldSpec;
+};

package/dist/via/classified/resolve.d.ts

@@ -0,0 +1,9 @@
+/** Flatten a classifiedFields config into a per-field map + rider computed entries. @module */
+import { type ClassifiedEntry, type ClassifiedFieldSpec } from './descriptor.js';
+export type { ClassifiedEntry, ClassifiedFieldSpec, ClassifiedGroup, ClassifiedList } from './descriptor.js';
+export { ClassifiedConfigError } from './errors.js';
+export interface ResolvedClassified {
+    readonly byField: Record<string, ClassifiedFieldSpec>;
+    readonly riderComputed: Record<string, (record: Record<string, unknown>) => unknown>;
+}
+export declare function resolveClassifiedFields(collection: string, config: Record<string, ClassifiedEntry>): ResolvedClassified;

package/dist/via/classified/strategy.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The ② capability seam for classified read-egress ops (stage 1: reveal;
+ * stage 2: verify). `ClassifiedStrategy` + `ClassifiedRevealCtx` +
+ * `ClassifiedVerifyCtx` + `NO_CLASSIFIED` now live on the kernel port
+ * (`port/with/classified-strategy.ts`, #629 Task 5) — re-exported here for
+ * compat with existing importers of this module.
+ *
+ * @internal
+ */
+export type { ClassifiedStrategy, ClassifiedRevealCtx, ClassifiedVerifyCtx, ClassifiedVerdict } from '../../port/with/classified-strategy.js';
+export { NO_CLASSIFIED } from '../../port/with/classified-strategy.js';

package/dist/via/classified/validators.d.ts

@@ -0,0 +1,3 @@
+/** Pure write-time validators. Exported so userland can validate storage:'never'
+ *  fields (e.g. CVC) at capture, before dropping them. @module */
+export declare function luhnCheck(pan: string): boolean;

package/dist/via/classified/write.d.ts

@@ -0,0 +1,4 @@
+/** Write-path enforcement: storage:'never' rejection + preset validators.
+ *  Runs BEFORE riders/computed and BEFORE schema validation. Pure. @module */
+import type { ClassifiedFieldSpec } from './descriptor.js';
+export declare function enforceClassifiedWrite(record: Record<string, unknown>, byField: Record<string, ClassifiedFieldSpec>, collection: string): void;

package/dist/via/computed/binding.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The `computed` via-binding (#638 Task 7) — covers ONLY `mode: 'virtual'`
+ * fields. Materialized entries never reach here: they compile into
+ * `mergedComputed` (`kernel/collection-config.ts`) and run through the
+ * EXISTING stage-5 `evalComputedFields` write path, byte-for-byte unchanged
+ * (the behavior lock).
+ *
+ * A virtual field is computed on READ, inside `present()` — the money-
+ * `Formatted`/i18n-`Label` precedent (seam map Part 4) generalized to a
+ * user-declared function. It is NEVER stored (no `encodeAtRest`/
+ * `decodeAtRest` — the field never appears in `_data` or any `_sealed`
+ * slot), and its posture is fixed `queryable: 'none'` — there is no stored/
+ * indexed form to query against, regardless of what its sources would
+ * otherwise permit (`ViaGraph`'s grain-'virtual' clamp, `kernel/via/graph.ts`,
+ * is the belt; this binding's own static posture is the suspenders for a
+ * depsless virtual field, which registers no graph edge at all).
+ *
+ * Export/read redaction for a TAINTED virtual field (sourced from a
+ * classified/sealed field) is NOT this binding's job — it stays ignorant of
+ * taint, exactly like `evalComputedFields` stays ignorant of it for
+ * materialized fields. `kernel/via/taint-binding.ts#taintBinding` (appended
+ * to the pipeline by `via/graph-wiring.ts#applyTaintOverlay`, AFTER this
+ * binding) overwrites a tainted virtual field's value with the same
+ * `EXPORT_REDACTION_MARKER` on every present() — the one enforcement seam
+ * every via feature's taint already routes through.
+ */
+import type { ViaBinding } from '../../kernel/via/index.js';
+import type { ComputedDescriptor } from './descriptor.js';
+export interface ComputedViaConfig {
+    /** field name -> its virtual-mode descriptor. Materialized entries are never present here. */
+    readonly virtualFields: ReadonlyMap<string, ComputedDescriptor>;
+}
+export declare function computedBinding(cfg: ComputedViaConfig): ViaBinding;
+export declare function linkComputedVia(): void;

package/dist/via/computed/descriptor.d.ts

@@ -0,0 +1,35 @@
+/**
+ * computed() — the declaration factory for a field whose value is DERIVED
+ * from other fields on the same record (#638 Task 7, spec §6). Composes
+ * with `via()` (the locked grammar since phase A: `via(computed(fn, { deps,
+ * mode }), money('EUR'))`), grouped by `_viaBrand` like every other via
+ * feature (`kernel/via/compose.ts#mergeViaFields`).
+ *
+ * `mode` picks where the function runs:
+ *  - `'materialized'` (default) — TODAY's stage-5 write-time eager compute
+ *    (`with-formula/computed/index.ts#evalComputedFields`), stored like any
+ *    other field. Byte-for-byte the existing `computed: { field: fn }` sugar.
+ *  - `'virtual'` — rides the `present` read phase (the money-`Formatted`/
+ *    i18n-`Label` precedent, seam map Part 4): computed fresh on every
+ *    read, NEVER stored, `queryable: 'none'`, excluded from export unless
+ *    its declared `deps` permit (identical taint rule to materialized —
+ *    see `via/computed/binding.ts`).
+ *
+ * `deps` names the OTHER fields `fn` reads — feeds `ViaGraph` (Task 1/2) so
+ * a source's taint (e.g. a classified field) propagates to this derived
+ * field. A depsless entry is fine UNLESS the collection also declares
+ * classified fields (`kernel/collection-config.ts#resolveComputedEdges`
+ * refuses it — closes the #636 opaque-function leak).
+ */
+import type { ViaDescriptor } from '../../kernel/via/index.js';
+export interface ComputedDescriptor extends ViaDescriptor {
+    readonly _viaBrand: 'computed';
+    readonly fn: (record: Record<string, unknown>) => unknown;
+    readonly deps?: readonly string[];
+    readonly mode: 'materialized' | 'virtual';
+}
+export declare function computed(fn: (record: Record<string, unknown>) => unknown, opts?: {
+    readonly deps?: readonly string[];
+    readonly mode?: 'materialized' | 'virtual';
+}): ComputedDescriptor;
+export declare function isComputedDescriptor(x: unknown): x is ComputedDescriptor;

package/dist/via/i18n/active.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Active i18n strategy — `withI18n()` returns the real implementation
+ * that wires multi-locale resolution, i18nText validation, and the
+ * `DictionaryHandle` for `dictKey` fields into the core read/write
+ * paths.
+ *
+ * Consumers opt in by:
+ *
+ * ```ts
+ * import { createNoydb } from '@noy-db/hub'
+ * import { withI18n } from '@noy-db/hub/i18n'
+ *
+ * const db = await createNoydb({
+ *   store: ...,
+ *   user: ...,
+ *   i18nStrategy: withI18n(),
+ * })
+ * ```
+ *
+ * The factory delegates to the existing `core.ts` and `dictionary.ts`
+ * modules. Splitting the import chain through this file is what lets
+ * tsup tree-shake the `~854 LOC` of dictionary + locale resolution
+ * out of the default bundle when no `withI18n()` import is present.
+ *
+ * @public
+ */
+import type { I18nStrategy } from './strategy.js';
+export declare function withI18n(): I18nStrategy;

package/dist/via/i18n/binding.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The i18n `ViaBinding` — wires the i18n engine (auto-translate/script
+ * enforcement/validation/densify on write; locale + dict-label presentation
+ * on read) into the kernel's generic Via port. Mirrors
+ * `via/money/binding.ts`'s #553 static-link pattern.
+ *
+ * LIVE (#623 Task 8 wired the cutover): `i18nBinding()`/`linkI18nVia()` are
+ * the real put/read path for every i18n-declaring collection —
+ * `collection.ts`'s `_putInternal`/`applyLocaleToRecord` (the call sites
+ * this file's bodies were moved/adapted from) now delegate their i18n
+ * stages to `this.via.encodeWrite`/`this.via.present` instead of running
+ * the hand-wired i18n logic inline.
+ *
+ * `i18nText()`, `dictKey()`, `staticDict()` each call {@link linkI18nVia}
+ * first — the same #553 pattern `money()` uses.
+ */
+import type { ViaBinding } from '../../kernel/via/index.js';
+/**
+ * Config a collection's i18n declarations resolve to — the binding's
+ * construction input. Fields are loosely typed (`unknown`) at this seam
+ * because the kernel's `ViaBinder` contract is opaque-config-in; the
+ * concrete i18n types are applied inside the binding's own functions.
+ */
+export interface I18nViaConfig {
+    i18nFields?: Record<string, unknown>;
+    dictKeyFields?: Record<string, unknown>;
+    i18nDensifyFields?: Record<string, unknown>;
+    strategy: unknown;
+    defaultLocale?: string;
+    autoTranslateHook?: (...args: unknown[]) => Promise<string>;
+    dictLabelResolver?: (...args: unknown[]) => Promise<string | undefined>;
+    i18nPutValidator?: (record: unknown) => void;
+    collectionName: string;
+}
+export declare function i18nBinding(cfg: I18nViaConfig): ViaBinding;
+export declare function linkI18nVia(): void;