@jini-ai/platform 0.5.0 → 0.5.2

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @jini-ai/platform
 
+## 0.5.2
+
+### Patch Changes
+
+- Tovu clean-up release (2026-10-08): code Tovu moved into Jini, plus the Jini clean-up (see the commit log since 0.5.1).
+
+## 0.5.1 — 2026-10-04
+
+- `./secrets` exports the canonical site-key names (`SiteKeyHandle`, `FixedSiteKeyKeyring`, `UnusableSiteKeyError`, `SiteKeyFileAlreadyExistsError`, `parseSiteKeyHex`, `fingerprintSiteKeyHex`, `inspectSiteKeyMaterial`, `revealSiteKeyMaterial`, `generateFileSiteKey`, `deriveFromSiteKey`, `deriveSigningSecretFromSiteKey` and the matching types). Every `RootKey*` name stays exported as a `@deprecated` alias of the same binding, to be removed on or after 2026-11-01. Additive: no behavior or signature change.
+
 ## 0.5.0 — 2026-10-02
 
 ### BREAKING

package/dist/fs/strict-containment.d.ts

@@ -1,5 +1,5 @@
 export declare function resolvePathWithin({ root, segment }: {
     root: string;
     segment: string;
-}): string | null;
+}, _optional?: Record<string, never>): string | null;
 //# sourceMappingURL=strict-containment.d.ts.map

package/dist/fs/strict-containment.js

@@ -1,6 +1,6 @@
 /** Preserve strict lexical containment: relative roots, root equality and traversal are refused (except the filesystem-root edge case). Symlinks require a separate physical-path guard. */
 import path from "node:path";
-export function resolvePathWithin({ root, segment }) {
+export function resolvePathWithin({ root, segment }, _optional = {}) {
     const resolved = path.resolve(root, segment);
     if (resolved !== path.join(root, segment))
         return null;

package/dist/http/guarded/transport.fetch.d.ts

@@ -1,8 +1,20 @@
+import { type ClientRequest, type IncomingMessage } from "node:http";
+import { type RequestOptions } from "node:https";
 import type { HttpRequest, HttpResponse } from "@jini-ai/core/primitives";
 import type { PinnedPeer } from "./types.js";
 import type { HttpTransportAdapter } from "./ports.js";
+/** Native request effect port; peer pinning and TLS options remain owned by this adapter. */
+export interface NativeHttpTransportOptions {
+    /** Like node:http, invoke onResponse asynchronously, after returning the request handle. */
+    request?: (input: {
+        secure: boolean;
+        options: RequestOptions;
+        onResponse: (response: IncomingMessage) => void;
+    }, optional?: Record<string, never>) => ClientRequest;
+}
 export declare class FetchHttpTransportAdapter implements HttpTransportAdapter {
-    constructor(_required: Record<string, never>);
+    private readonly optional;
+    constructor(_required: Record<string, never>, optional?: NativeHttpTransportOptions);
     requestPinned({ request: req, peer }: {
         request: HttpRequest;
         peer: PinnedPeer;

package/dist/http/guarded/transport.fetch.js

@@ -11,7 +11,10 @@ import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
 /** Last-resort decoded-byte bound independent of any caller's response policy. */
 const ABSOLUTE_MAX_BYTES = 100 * 1024 * 1024;
 export class FetchHttpTransportAdapter {
-    constructor(_required) { }
+    optional;
+    constructor(_required, optional = {}) {
+        this.optional = optional;
+    }
     async requestPinned({ request: req, peer }) {
         const url = new URL(req.url);
         const isHttps = url.protocol === "https:";
@@ -31,7 +34,7 @@ export class FetchHttpTransportAdapter {
             ...(isHttps && peer.tlsServerName ? { servername: peer.tlsServerName } : {}),
         };
         return new Promise((resolve, reject) => {
-            const clientRequest = requestFn(options, (res) => {
+            const onResponse = (res) => {
                 // HEAD can advertise GET's compression but has no body to decompress.
                 const decoded = req.method === "HEAD" ? res : decodeBody(res.headers["content-encoding"], res);
                 const chunks = [];
@@ -74,7 +77,10 @@ export class FetchHttpTransportAdapter {
                 });
                 decoded.on("end", () => finish(false));
                 decoded.on("error", reject);
-            });
+            };
+            const clientRequest = this.optional.request
+                ? this.optional.request({ secure: isHttps, options, onResponse }, {})
+                : requestFn(options, onResponse);
             clientRequest.on("timeout", () => {
                 clientRequest.destroy(new Error(`request timed out after ${idleTimeoutMs}ms`));
             });

package/dist/index.d.ts

@@ -10,7 +10,7 @@
  * - `fs`         — filesystem containment, atomic copy, removal, log tails.
  * - `http`       — HTTP readiness polling.
  * - `fetch-with-timeout` — the shared `AbortSignal`-timeout wrapper every outbound `fetch()` call
- *   in this monorepo is meant to go through (2026-08-16 failure-mode audit, Finding 2).
+ *   in this monorepo is meant to go through.
  * - `toolchain`  — user-level toolchain bin discovery.
  * - `asset-cache` — SSRF-safe same-origin cache/proxy for sandboxed content's
  *   external media references.
@@ -26,59 +26,10 @@
  * - `blob-storage` — a backend-agnostic blob storage port + local-disk and
  *   S3-compatible implementations.
  *
- * The set of names exported here is intentionally identical to the pre-split
- * public surface; importers see no change.
 
- * Archived provenance rationale:
- * ## Design decision: `project-storage.ts` was split, not ported wholesale or dropped
- *
- * The task brief asked to verify the recon's "leans OD" flag on
- * `project-storage.ts` firsthand and either drop it or extract a generic core
- * with OD's project-specific parts as an adapter, "depending on what you
- * actually find." Read in full: the `ProjectStorage` interface,
- * `LocalProjectStorage`, and `S3ProjectStorage` classes carry no OD nouns in
- * their own logic — they're a backend-agnostic blob CRUD port (read/write/
- * list/delete/stat under a scoping key) plus a local-disk and an
- * S3-compatible implementation, both traversal-guarded. The **only** OD
- * coupling in the file is the bottom `resolveProjectStorage()` factory
- * function, which reads `OD_PROJECT_STORAGE`/`OD_S3_BUCKET`/`OD_S3_REGION`/
- * `OD_S3_PREFIX`/`OD_S3_ENDPOINT`/`OD_S3_ACCESS_KEY_ID`/
- * `OD_S3_SECRET_ACCESS_KEY`/`OD_S3_SESSION_TOKEN` directly from `process.env`.
- *
- * **Extracted, not dropped:** the interface + both implementations, ported to
- * `src/blob-storage.ts` as `BlobStorage`/`BlobFileMeta`/`LocalBlobStorage`/
- * `S3BlobStorage`/`S3BlobStorageOptions`/`StorageError`, with every
- * `projectId: string` parameter renamed to `namespace: string` — per
- * extraction-plan.md's Task-4 Port-2 finding ("OD's 'project' is a product
- * model; engine needs a generic workspace/session store interface") and §2.1's
- * "Runs key on an opaque `contextRef`, never `projectId`" convention, "project"
- * specifically is flagged elsewhere in this porting effort as OD's noun, not
- * the engine's — `namespace` carries no domain meaning here beyond "a
- * top-level grouping/scoping key," which is what the parameter actually is
- * structurally (nothing in `LocalBlobStorage`/`S3BlobStorage`'s logic assumes
- * it means a design project).
- *
- * **Dropped, not ported:** `resolveProjectStorage()`. This is OD adapter
- * wiring — a specific env-var-naming convention and the choice to read
- * `process.env` directly inside the engine layer — not generic engine
- * behavior. It has no equivalent anywhere else in this porting session's
- * established pattern (`createSqliteEventLog`, `LocalBlobStorage`,
- * `S3BlobStorage` are all called with explicit constructor arguments; none of
- * `@jini/*`'s existing adapters read `process.env` inside their own
- * constructors). A Jini host application composes its own equivalent
- * (`new LocalBlobStorage(root)` or `new S3BlobStorage({ bucket, region,
- * credentials, ... })` called directly, with whatever env-var convention that
- * host prefers) rather than inheriting OD's `OD_S3_*` names or its
- * env-selection shape.
- *
- * Landed in `@jini/platform`, not `@jini/sqlite`: this is a filesystem/network
- * blob-storage primitive with no SQL involvement, parallel to this package's
- * existing `fs.ts` (path containment / atomic copy) and `http.ts` (readiness
- * polling) roles — `@jini/sqlite` is reserved for the `EventLog` port adapter
- * and `better-sqlite3`-specific helpers (`db-inspect.ts`,
- * `backend-config.ts`), none of which this needs. `aws-sigv4.ts` lives
- * alongside it in the same package since it's `S3BlobStorage`'s only
- * dependency and has no other consumer yet.
+ * Blob storage uses opaque namespace scoping rather than a product's project model. Hosts supply
+ * configuration/credentials explicitly instead of inheriting product-prefixed environment names.
+ * Filesystem/network storage and its SigV4 signing belong here, with no kernel SQL-port dependency.
  */
 export type { CommandInvocation, CommandInvocationRequest } from "./command.js";
 export { createCommandInvocation, createPackageManagerInvocation } from "./command.js";

package/dist/index.js

@@ -10,7 +10,7 @@
  * - `fs`         — filesystem containment, atomic copy, removal, log tails.
  * - `http`       — HTTP readiness polling.
  * - `fetch-with-timeout` — the shared `AbortSignal`-timeout wrapper every outbound `fetch()` call
- *   in this monorepo is meant to go through (2026-08-16 failure-mode audit, Finding 2).
+ *   in this monorepo is meant to go through.
  * - `toolchain`  — user-level toolchain bin discovery.
  * - `asset-cache` — SSRF-safe same-origin cache/proxy for sandboxed content's
  *   external media references.
@@ -26,59 +26,10 @@
  * - `blob-storage` — a backend-agnostic blob storage port + local-disk and
  *   S3-compatible implementations.
  *
- * The set of names exported here is intentionally identical to the pre-split
- * public surface; importers see no change.
 
- * Archived provenance rationale:
- * ## Design decision: `project-storage.ts` was split, not ported wholesale or dropped
- *
- * The task brief asked to verify the recon's "leans OD" flag on
- * `project-storage.ts` firsthand and either drop it or extract a generic core
- * with OD's project-specific parts as an adapter, "depending on what you
- * actually find." Read in full: the `ProjectStorage` interface,
- * `LocalProjectStorage`, and `S3ProjectStorage` classes carry no OD nouns in
- * their own logic — they're a backend-agnostic blob CRUD port (read/write/
- * list/delete/stat under a scoping key) plus a local-disk and an
- * S3-compatible implementation, both traversal-guarded. The **only** OD
- * coupling in the file is the bottom `resolveProjectStorage()` factory
- * function, which reads `OD_PROJECT_STORAGE`/`OD_S3_BUCKET`/`OD_S3_REGION`/
- * `OD_S3_PREFIX`/`OD_S3_ENDPOINT`/`OD_S3_ACCESS_KEY_ID`/
- * `OD_S3_SECRET_ACCESS_KEY`/`OD_S3_SESSION_TOKEN` directly from `process.env`.
- *
- * **Extracted, not dropped:** the interface + both implementations, ported to
- * `src/blob-storage.ts` as `BlobStorage`/`BlobFileMeta`/`LocalBlobStorage`/
- * `S3BlobStorage`/`S3BlobStorageOptions`/`StorageError`, with every
- * `projectId: string` parameter renamed to `namespace: string` — per
- * extraction-plan.md's Task-4 Port-2 finding ("OD's 'project' is a product
- * model; engine needs a generic workspace/session store interface") and §2.1's
- * "Runs key on an opaque `contextRef`, never `projectId`" convention, "project"
- * specifically is flagged elsewhere in this porting effort as OD's noun, not
- * the engine's — `namespace` carries no domain meaning here beyond "a
- * top-level grouping/scoping key," which is what the parameter actually is
- * structurally (nothing in `LocalBlobStorage`/`S3BlobStorage`'s logic assumes
- * it means a design project).
- *
- * **Dropped, not ported:** `resolveProjectStorage()`. This is OD adapter
- * wiring — a specific env-var-naming convention and the choice to read
- * `process.env` directly inside the engine layer — not generic engine
- * behavior. It has no equivalent anywhere else in this porting session's
- * established pattern (`createSqliteEventLog`, `LocalBlobStorage`,
- * `S3BlobStorage` are all called with explicit constructor arguments; none of
- * `@jini/*`'s existing adapters read `process.env` inside their own
- * constructors). A Jini host application composes its own equivalent
- * (`new LocalBlobStorage(root)` or `new S3BlobStorage({ bucket, region,
- * credentials, ... })` called directly, with whatever env-var convention that
- * host prefers) rather than inheriting OD's `OD_S3_*` names or its
- * env-selection shape.
- *
- * Landed in `@jini/platform`, not `@jini/sqlite`: this is a filesystem/network
- * blob-storage primitive with no SQL involvement, parallel to this package's
- * existing `fs.ts` (path containment / atomic copy) and `http.ts` (readiness
- * polling) roles — `@jini/sqlite` is reserved for the `EventLog` port adapter
- * and `better-sqlite3`-specific helpers (`db-inspect.ts`,
- * `backend-config.ts`), none of which this needs. `aws-sigv4.ts` lives
- * alongside it in the same package since it's `S3BlobStorage`'s only
- * dependency and has no other consumer yet.
+ * Blob storage uses opaque namespace scoping rather than a product's project model. Hosts supply
+ * configuration/credentials explicitly instead of inheriting product-prefixed environment names.
+ * Filesystem/network storage and its SigV4 signing belong here, with no kernel SQL-port dependency.
  */
 export { createCommandInvocation, createPackageManagerInvocation } from "./command.js";
 export { mergeProxyAwareEnv, parseMacosScutilProxyOutput, parseWindowsInternetSettingsProxyOutput, resolveSystemProxyEnv, } from "./proxy-env.js";

package/dist/net/address.d.ts

@@ -23,14 +23,7 @@ export declare function expandIpv6({ address: addr }: {
 export declare function isPrivateAddress({ address: addr }: {
     address: string;
 }): boolean;
-/** True for `localhost`, `::1`, `127.0.0.0/8`, and their IPv4-mapped-IPv6 forms. */
-export declare function isLoopbackApiHost({ hostname }: {
-    hostname: string;
-}): boolean;
-/** True for RFC1918/link-local/CGNAT/multicast/unspecified/unique-local-IPv6 addresses — private network space a public caller should never be steered into. */
-export declare function isBlockedExternalApiHostname({ hostname }: {
-    hostname: string;
-}): boolean;
+export { isLoopbackApiHost, isBlockedExternalApiHostname } from './endpoint-policy.js';
 /** True when `hostname` is `localhost`, an IPv6 loopback literal, or a `127.0.0.0/8` IPv4 literal. */
 export declare function isLoopbackHostname({ hostname }: {
     readonly hostname: unknown;

package/dist/net/address.js

@@ -135,95 +135,8 @@ export function isPrivateAddress({ address: addr }) {
     }
     return true; // not a literal IP — caller must resolve before trusting it
 }
-function normalizeBracketedIpv6(hostname) {
-    const stripped = hostname.startsWith('[') && hostname.endsWith(']')
-        ? hostname.slice(1, -1)
-        : hostname;
-    // FQDN trailing-dot form (RFC 1034) resolves identically to the dotless
-    // form, so `localhost.` must normalize to `localhost` before the equality
-    // check below — and `0.0.0.0.`, `10.0.0.1.`, etc. must normalize before
-    // isBlockedIpv4 parses them. Strips one or more trailing dots.
-    return stripped.toLowerCase().replace(/\.+$/, '');
-}
-function parseIpv4(hostname) {
-    const parts = hostname.split('.');
-    if (parts.length !== 4)
-        return null;
-    const parsed = parts.map((part) => {
-        if (!/^\d{1,3}$/.test(part))
-            return null;
-        const value = Number(part);
-        return value >= 0 && value <= 255 ? value : null;
-    });
-    if (parsed.some((part) => part === null))
-        return null;
-    return [parsed[0], parsed[1], parsed[2], parsed[3]];
-}
-function isLoopbackIpv4(hostname) {
-    const parts = parseIpv4(hostname);
-    return Boolean(parts && parts[0] === 127);
-}
-function isBlockedIpv4(hostname) {
-    const parts = parseIpv4(hostname);
-    if (!parts)
-        return false;
-    const [a, b] = parts;
-    return (a === 0 ||
-        (a === 100 && b >= 64 && b <= 127) ||
-        (a === 169 && b === 254) ||
-        a === 10 ||
-        (a === 192 && b === 168) ||
-        (a === 172 && b >= 16 && b <= 31) ||
-        a >= 224);
-}
-function ipv4MappedToDotted(hostname) {
-    const host = normalizeBracketedIpv6(hostname);
-    const mapped = /^::ffff:(.+)$/i.exec(host)?.[1];
-    if (!mapped)
-        return null;
-    if (parseIpv4(mapped.toLowerCase()))
-        return mapped.toLowerCase();
-    const hexParts = mapped.split(':');
-    if (hexParts.length !== 2 ||
-        !hexParts.every((part) => /^[0-9a-f]{1,4}$/i.test(part))) {
-        return null;
-    }
-    // Non-null assertions, not a runtime guard: the length/regex checks above
-    // already guarantee exactly two non-empty hex segments here.
-    const hi = hexParts[0];
-    const lo = hexParts[1];
-    const value = (Number.parseInt(hi, 16) << 16) | Number.parseInt(lo, 16);
-    return [
-        (value >>> 24) & 255,
-        (value >>> 16) & 255,
-        (value >>> 8) & 255,
-        value & 255,
-    ].join('.');
-}
-/** True for `localhost`, `::1`, `127.0.0.0/8`, and their IPv4-mapped-IPv6 forms. */
-export function isLoopbackApiHost({ hostname }) {
-    const host = normalizeBracketedIpv6(hostname);
-    if (host === 'localhost' || host === '::1')
-        return true;
-    if (isLoopbackIpv4(host))
-        return true;
-    const mapped = ipv4MappedToDotted(host);
-    return Boolean(mapped && isLoopbackIpv4(mapped));
-}
-/** True for RFC1918/link-local/CGNAT/multicast/unspecified/unique-local-IPv6 addresses — private network space a public caller should never be steered into. */
-export function isBlockedExternalApiHostname({ hostname }) {
-    const host = normalizeBracketedIpv6(hostname);
-    if (host === '::')
-        return true;
-    if (isBlockedIpv4(host))
-        return true;
-    if (/^f[cd][0-9a-f]{2}:/i.test(host))
-        return true;
-    if (/^fe[89ab][0-9a-f]:/i.test(host))
-        return true;
-    const mapped = ipv4MappedToDotted(host);
-    return Boolean(mapped && isBlockedIpv4(mapped));
-}
+// Preserve the Node entry's published names while sharing the literal-host owner with browser consumers.
+export { isLoopbackApiHost, isBlockedExternalApiHostname } from './endpoint-policy.js';
 /** True when `hostname` is `localhost`, an IPv6 loopback literal, or a `127.0.0.0/8` IPv4 literal. */
 export function isLoopbackHostname({ hostname }, _optional = {}) {
     const normalized = String(hostname || '')

package/dist/net/endpoint-policy.d.ts

@@ -0,0 +1,9 @@
+/** True for `localhost`, `::1`, `127.0.0.0/8`, and their IPv4-mapped-IPv6 forms. */
+export declare function isLoopbackApiHost({ hostname }: {
+    hostname: string;
+}): boolean;
+/** True for RFC1918/link-local/CGNAT/multicast/unspecified/unique-local-IPv6 addresses — private network space a public caller should never be steered into. */
+export declare function isBlockedExternalApiHostname({ hostname }: {
+    hostname: string;
+}): boolean;
+//# sourceMappingURL=endpoint-policy.d.ts.map

package/dist/net/endpoint-policy.js

@@ -0,0 +1,98 @@
+/**
+ * Browser-safe literal endpoint hostname policy. No Node imports or DNS effects:
+ * operator-configured local model servers deliberately keep their loopback
+ * exception. Resolved-peer validation and strict IP parsing belong to the Node
+ * adapters, whose different trust boundaries must not be collapsed into this.
+ * SSRF peer classification is distinct from core's browser-development LAN origin allow-list.
+ */
+function normalizeBracketedIpv6(hostname) {
+    const stripped = hostname.startsWith('[') && hostname.endsWith(']')
+        ? hostname.slice(1, -1)
+        : hostname;
+    // FQDN trailing-dot form (RFC 1034) resolves identically to the dotless
+    // form, so `localhost.` must normalize to `localhost` before the equality
+    // check below — and `0.0.0.0.`, `10.0.0.1.`, etc. must normalize before
+    // isBlockedIpv4 parses them. Strips one or more trailing dots.
+    return stripped.toLowerCase().replace(/\.+$/, '');
+}
+function parseIpv4(hostname) {
+    const parts = hostname.split('.');
+    if (parts.length !== 4)
+        return null;
+    const parsed = parts.map((part) => {
+        if (!/^\d{1,3}$/.test(part))
+            return null;
+        const value = Number(part);
+        return value >= 0 && value <= 255 ? value : null;
+    });
+    if (parsed.some((part) => part === null))
+        return null;
+    return [parsed[0], parsed[1], parsed[2], parsed[3]];
+}
+function isLoopbackIpv4(hostname) {
+    const parts = parseIpv4(hostname);
+    return Boolean(parts && parts[0] === 127);
+}
+function isBlockedIpv4(hostname) {
+    const parts = parseIpv4(hostname);
+    if (!parts)
+        return false;
+    const [a, b] = parts;
+    return (a === 0 ||
+        (a === 100 && b >= 64 && b <= 127) ||
+        (a === 169 && b === 254) ||
+        a === 10 ||
+        (a === 192 && b === 168) ||
+        (a === 172 && b >= 16 && b <= 31) ||
+        a >= 224);
+}
+/** `::ffff:10.0.0.1` and `::ffff:a00:1` denote the same address; return dotted form so the v4 rules apply. */
+function ipv4MappedToDotted(hostname) {
+    const host = normalizeBracketedIpv6(hostname);
+    const mapped = /^::ffff:(.+)$/i.exec(host)?.[1];
+    if (!mapped)
+        return null;
+    if (parseIpv4(mapped.toLowerCase()))
+        return mapped.toLowerCase();
+    const hexParts = mapped.split(':');
+    if (hexParts.length !== 2 ||
+        !hexParts.every((part) => /^[0-9a-f]{1,4}$/i.test(part))) {
+        return null;
+    }
+    // Non-null assertions, not a runtime guard: the length/regex checks above
+    // already guarantee exactly two non-empty hex segments here.
+    const hi = hexParts[0];
+    const lo = hexParts[1];
+    const value = (Number.parseInt(hi, 16) << 16) | Number.parseInt(lo, 16);
+    return [
+        (value >>> 24) & 255,
+        (value >>> 16) & 255,
+        (value >>> 8) & 255,
+        value & 255,
+    ].join('.');
+}
+/** True for `localhost`, `::1`, `127.0.0.0/8`, and their IPv4-mapped-IPv6 forms. */
+export function isLoopbackApiHost({ hostname }) {
+    const host = normalizeBracketedIpv6(hostname);
+    if (host === 'localhost' || host === '::1')
+        return true;
+    if (isLoopbackIpv4(host))
+        return true;
+    const mapped = ipv4MappedToDotted(host);
+    return Boolean(mapped && isLoopbackIpv4(mapped));
+}
+/** True for RFC1918/link-local/CGNAT/multicast/unspecified/unique-local-IPv6 addresses — private network space a public caller should never be steered into. */
+export function isBlockedExternalApiHostname({ hostname }) {
+    const host = normalizeBracketedIpv6(hostname);
+    if (host === '::')
+        return true;
+    if (isBlockedIpv4(host))
+        return true;
+    if (/^f[cd][0-9a-f]{2}:/i.test(host))
+        return true;
+    if (/^fe[89ab][0-9a-f]:/i.test(host))
+        return true;
+    const mapped = ipv4MappedToDotted(host);
+    return Boolean(mapped && isBlockedIpv4(mapped));
+}
+//# sourceMappingURL=endpoint-policy.js.map

package/dist/secrets/credential-sets/repo.memory.d.ts

@@ -1,36 +1,44 @@
 import type { VendorCredentialSetRecord, VendorCredentialSetRepoPort } from "./types.js";
-/** In-memory repository preserving label uniqueness and group default promotion. */
+/**
+ * @file `VendorCredentialSetRepoPort`'s in-memory adapter — the ADR-006 rule-of-two test double,
+ * mirroring `../deployments/publish-credentials/repo.memory.ts`'s shape byte-for-byte with
+ * `providerId` swapped for `vendorId`. See that file's own header for the full reasoning (row
+ * keying, the enforced UNIQUE constraint matching better-sqlite3's own error wording, why no
+ * explicit lock is needed for the `isDefault` group invariant in a single-threaded JS process).
+ */
 export declare class InMemoryVendorCredentialSetRepo implements VendorCredentialSetRepoPort {
-    constructor(_required: Record<string, never>);
+    constructor(_required: Record<string, never>, _optional?: Record<string, never>);
     private readonly rows;
     private static rowKey;
     private assertLabelAvailable;
     private clearOtherDefaults;
-    insert(record: VendorCredentialSetRecord): Promise<void>;
-    update(record: VendorCredentialSetRecord): Promise<void>;
+    insert(record: VendorCredentialSetRecord, _optional?: Record<string, never>): Promise<void>;
+    update(record: VendorCredentialSetRecord, _optional?: Record<string, never>): Promise<void>;
     findById(input: {
         workspaceId: string;
         id: string;
-    }): Promise<VendorCredentialSetRecord | null>;
+    }, _optional?: Record<string, never>): Promise<VendorCredentialSetRecord | null>;
     findDefaultByVendor(input: {
         workspaceId: string;
         vendorId: string;
-    }): Promise<VendorCredentialSetRecord | null>;
+    }, _optional?: Record<string, never>): Promise<VendorCredentialSetRecord | null>;
     listByVendor(input: {
         workspaceId: string;
         vendorId: string;
-    }): Promise<VendorCredentialSetRecord[]>;
+    }, _optional?: Record<string, never>): Promise<VendorCredentialSetRecord[]>;
     listByWorkspace(input: {
         workspaceId: string;
-    }): Promise<VendorCredentialSetRecord[]>;
+    }, _optional?: Record<string, never>): Promise<VendorCredentialSetRecord[]>;
     delete(input: {
         workspaceId: string;
         id: string;
-    }): Promise<void>;
+    }, _optional?: Record<string, never>): Promise<void>;
+    /** Mirrors the SQLite adapter's targeted single-column write — see
+     *  `VendorCredentialSetRepoPort.updateAccountLabel`'s own doc. No-op if the row vanished. */
     updateAccountLabel(input: {
         workspaceId: string;
         id: string;
         accountLabel: string;
-    }): Promise<void>;
+    }, _optional?: Record<string, never>): Promise<void>;
 }
 //# sourceMappingURL=repo.memory.d.ts.map

package/dist/secrets/credential-sets/repo.memory.js

@@ -1,6 +1,12 @@
-/** In-memory repository preserving label uniqueness and group default promotion. */
+/**
+ * @file `VendorCredentialSetRepoPort`'s in-memory adapter — the ADR-006 rule-of-two test double,
+ * mirroring `../deployments/publish-credentials/repo.memory.ts`'s shape byte-for-byte with
+ * `providerId` swapped for `vendorId`. See that file's own header for the full reasoning (row
+ * keying, the enforced UNIQUE constraint matching better-sqlite3's own error wording, why no
+ * explicit lock is needed for the `isDefault` group invariant in a single-threaded JS process).
+ */
 export class InMemoryVendorCredentialSetRepo {
-    constructor(_required) { }
+    constructor(_required, _optional = {}) { }
     rows = new Map();
     static rowKey(workspaceId, id) {
         return `${workspaceId}::${id}`;
@@ -21,35 +27,35 @@ export class InMemoryVendorCredentialSetRepo {
             this.rows.set(key, { ...row, isDefault: false });
         }
     }
-    async insert(record) {
+    async insert(record, _optional = {}) {
         this.assertLabelAvailable(record.workspaceId, record.vendorId, record.label);
         this.rows.set(InMemoryVendorCredentialSetRepo.rowKey(record.workspaceId, record.id), { ...record });
         if (record.isDefault)
             this.clearOtherDefaults(record.workspaceId, record.vendorId, record.id);
     }
-    async update(record) {
+    async update(record, _optional = {}) {
         this.assertLabelAvailable(record.workspaceId, record.vendorId, record.label, record.id);
         this.rows.set(InMemoryVendorCredentialSetRepo.rowKey(record.workspaceId, record.id), { ...record });
         if (record.isDefault)
             this.clearOtherDefaults(record.workspaceId, record.vendorId, record.id);
     }
-    async findById(input) {
+    async findById(input, _optional = {}) {
         return this.rows.get(InMemoryVendorCredentialSetRepo.rowKey(input.workspaceId, input.id)) ?? null;
     }
-    async findDefaultByVendor(input) {
+    async findDefaultByVendor(input, _optional = {}) {
         for (const row of this.rows.values()) {
             if (row.workspaceId === input.workspaceId && row.vendorId === input.vendorId && row.isDefault)
                 return row;
         }
         return null;
     }
-    async listByVendor(input) {
+    async listByVendor(input, _optional = {}) {
         return [...this.rows.values()].filter((row) => row.workspaceId === input.workspaceId && row.vendorId === input.vendorId);
     }
-    async listByWorkspace(input) {
+    async listByWorkspace(input, _optional = {}) {
         return [...this.rows.values()].filter((row) => row.workspaceId === input.workspaceId);
     }
-    async delete(input) {
+    async delete(input, _optional = {}) {
         const key = InMemoryVendorCredentialSetRepo.rowKey(input.workspaceId, input.id);
         const removed = this.rows.get(key);
         this.rows.delete(key);
@@ -61,7 +67,9 @@ export class InMemoryVendorCredentialSetRepo {
         const promoted = remaining.reduce((latest, row) => (row.updatedAt > latest.updatedAt ? row : latest));
         this.rows.set(InMemoryVendorCredentialSetRepo.rowKey(promoted.workspaceId, promoted.id), { ...promoted, isDefault: true });
     }
-    async updateAccountLabel(input) {
+    /** Mirrors the SQLite adapter's targeted single-column write — see
+     *  `VendorCredentialSetRepoPort.updateAccountLabel`'s own doc. No-op if the row vanished. */
+    async updateAccountLabel(input, _optional = {}) {
         const key = InMemoryVendorCredentialSetRepo.rowKey(input.workspaceId, input.id);
         const existing = this.rows.get(key);
         if (!existing)

package/dist/secrets/credential-token.d.ts

@@ -0,0 +1,64 @@
+/** Shared credential validation; application detection policy is injected at the metadata boundary. */
+export declare const CREDENTIAL_TOKEN_LIMIT = 8192;
+export declare const CREDENTIAL_MESSAGES: {
+    readonly showSecret: "Show";
+    readonly hideSecret: "Hide";
+    readonly generationUnavailable: "Generation is not available yet for this provider.";
+    readonly secretValue: "Secret value";
+    readonly saveSecret: "Save secret";
+    readonly cancel: "Cancel";
+    readonly secretForm: "Enter the value in this secure form.";
+    readonly env: "Enter environment variables as NAME=VALUE lines or a JSON object of strings.";
+    readonly url: "The server URL must be a valid absolute URL.";
+    readonly set: "Access token set";
+    readonly storage: "The credential could not be saved or unlocked. Check the site credential store.";
+    readonly savedTitle: "Saved.";
+    readonly blank: "Enter a token. Spaces alone are not a token.";
+    readonly limit: "The token exceeds the 8192-character limit. Copy only the token.";
+    readonly ascii: "Hosted tokens must use visible ASCII characters (0x21–0x7E).";
+    readonly control: "The token contains an invalid control character.";
+    readonly plain: "Put credentials in the secret field, not in this field.";
+    readonly saved: "Saved, not tested.";
+    readonly connected: "Connected.";
+    readonly auth: "The server rejected this token.";
+    readonly timeout: "The connection timed out.";
+    readonly unreachable: "Could not reach the server.";
+    readonly chars: "{length} chars";
+};
+export type CredentialMessageId = keyof typeof CREDENTIAL_MESSAGES;
+/** Errors carry only a rule and field, never the submitted value. */
+export declare class CredentialInputError extends Error {
+    readonly rule: CredentialMessageId;
+    readonly field: string;
+    constructor(rule: CredentialMessageId, field: string);
+}
+/** Validate without normalizing: cards may call this before a probe; only the store trims. */
+export declare function assertCredentialToken({ value, field, hosted }: {
+    value: unknown;
+    field?: string;
+    hosted?: boolean;
+}, _optional?: {}): void;
+/** The single normalization boundary. Interior characters are never rewritten or truncated. */
+export declare function normalizeCredentialToken(required: {
+    value: unknown;
+    field?: string;
+    hosted?: boolean;
+}, _optional?: {}): string;
+export interface CredentialTokenHint {
+    length: number;
+    last4: string | null;
+}
+/** Call only on a server-side unsealed value; short tokens expose no characters. */
+export declare function credentialTokenHint({ token }: {
+    token: string;
+}, _optional?: {}): CredentialTokenHint;
+/** Protect plaintext metadata, using Jini's detector plus structural URL/CLI rules. */
+export declare function assertCredentialFreeField({ value, field, containsSecret }: {
+    value: string;
+    field: string;
+    containsSecret: (required: {
+        text: string;
+    }) => boolean;
+}, _optional?: {}): void;
+export type CredentialConnection = 'connected' | 'auth' | 'timeout' | 'unreachable' | 'saved';
+//# sourceMappingURL=credential-token.d.ts.map

package/dist/secrets/credential-token.js

@@ -0,0 +1,75 @@
+/** Shared credential validation; application detection policy is injected at the metadata boundary. */
+export const CREDENTIAL_TOKEN_LIMIT = 8192;
+export const CREDENTIAL_MESSAGES = {
+    showSecret: "Show",
+    hideSecret: "Hide",
+    generationUnavailable: "Generation is not available yet for this provider.",
+    secretValue: "Secret value",
+    saveSecret: "Save secret",
+    cancel: "Cancel",
+    secretForm: "Enter the value in this secure form.",
+    env: 'Enter environment variables as NAME=VALUE lines or a JSON object of strings.',
+    url: 'The server URL must be a valid absolute URL.',
+    set: 'Access token set',
+    storage: 'The credential could not be saved or unlocked. Check the site credential store.',
+    savedTitle: 'Saved.',
+    blank: 'Enter a token. Spaces alone are not a token.',
+    limit: 'The token exceeds the 8192-character limit. Copy only the token.',
+    ascii: 'Hosted tokens must use visible ASCII characters (0x21–0x7E).',
+    control: 'The token contains an invalid control character.',
+    plain: 'Put credentials in the secret field, not in this field.',
+    saved: 'Saved, not tested.',
+    connected: 'Connected.',
+    auth: 'The server rejected this token.',
+    timeout: 'The connection timed out.',
+    unreachable: 'Could not reach the server.',
+    chars: '{length} chars',
+};
+/** Errors carry only a rule and field, never the submitted value. */
+export class CredentialInputError extends Error {
+    rule;
+    field;
+    constructor(rule, field) {
+        super(CREDENTIAL_MESSAGES[rule]);
+        this.rule = rule;
+        this.field = field;
+        this.name = 'CredentialInputError';
+    }
+}
+/** Validate without normalizing: cards may call this before a probe; only the store trims. */
+export function assertCredentialToken({ value, field = 'token', hosted = true }, _optional = {}) {
+    if (typeof value !== 'string' || value.trim() === '')
+        throw new CredentialInputError('blank', field);
+    // Validate the stored length, so incidental edge whitespace does not consume the token limit.
+    const token = value.trim();
+    if (token.length > CREDENTIAL_TOKEN_LIMIT)
+        throw new CredentialInputError('limit', field);
+    if (hosted && /[^\x21-\x7e]/.test(token))
+        throw new CredentialInputError('ascii', field);
+    if (/[\x00-\x1f\x7f-\x9f]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(token)) {
+        throw new CredentialInputError('control', field);
+    }
+}
+/** The single normalization boundary. Interior characters are never rewritten or truncated. */
+export function normalizeCredentialToken(required, _optional = {}) {
+    assertCredentialToken(required);
+    return required.value.trim();
+}
+/** Call only on a server-side unsealed value; short tokens expose no characters. */
+export function credentialTokenHint({ token }, _optional = {}) {
+    return { length: token.length, last4: token.length >= 12 ? token.slice(-4) : null };
+}
+const SECRET_NAME = /(?:^|[_-])(?:key|api[_-]?key|token|access[_-]?token|secret|password|auth|sig)$/i;
+const SECRET_ARG = /(?:^|\s)--[\w-]*(?:api[_-]?key|token|secret|password)(?:=|\s+)(?!\s*$)\S/i;
+/** Protect plaintext metadata, using Jini's detector plus structural URL/CLI rules. */
+export function assertCredentialFreeField({ value, field, containsSecret }, _optional = {}) {
+    let credential = containsSecret({ text: value }) || SECRET_ARG.test(value);
+    try {
+        const url = new URL(value);
+        credential ||= url.username !== '' || url.password !== '' || [...url.searchParams.keys()].some(key => SECRET_NAME.test(key));
+    }
+    catch { /* A label/argument is ordinarily not an absolute URL. */ }
+    if (credential)
+        throw new CredentialInputError('plain', field);
+}
+//# sourceMappingURL=credential-token.js.map

package/dist/secrets/index.d.ts

@@ -1,9 +1,64 @@
 export type { SealedSecret } from "./types.js";
-export type { RootKeyHandle, KeyringPort, SecretSealerPort } from "./ports.js";
+export type { KeyringPort, SecretSealerPort } from "./ports.js";
 export { AesGcmSecretSealer } from "./secret-sealer.aesgcm.js";
-export { EnvOrFileKeyring, FixedRootKeyKeyring, UnusableRootKeyError, RootKeyFileAlreadyExistsError, parseRootKeyHex, fingerprintRootKeyHex, inspectRootKeyMaterial, revealRootKeyMaterial, generateFileRootKey, deriveFromRootKey, deriveSigningSecretFromRootKey, } from "./keyring.env.js";
-export type { EnvOrFileKeyringRequired, RootKeyEnvironmentPort, EnvOrFileKeyringOptions, RootKeyRejection, ParsedRootKeyHex, RootKeyStatus, RootKeyReveal, InspectRootKeyMaterialOptions, GeneratedFileRootKey, } from "./keyring.env.js";
+export { EnvOrFileKeyring } from "./keyring.env.js";
+export type { EnvOrFileKeyringRequired, EnvOrFileKeyringOptions } from "./keyring.env.js";
+export type { RootKeyHandle as SiteKeyHandle } from "./ports.js";
+export { FixedRootKeyKeyring as FixedSiteKeyKeyring } from "./keyring.env.js";
+export { UnusableRootKeyError as UnusableSiteKeyError } from "./keyring.env.js";
+export { RootKeyFileAlreadyExistsError as SiteKeyFileAlreadyExistsError } from "./keyring.env.js";
+export { parseRootKeyHex as parseSiteKeyHex } from "./keyring.env.js";
+export { fingerprintRootKeyHex as fingerprintSiteKeyHex } from "./keyring.env.js";
+export { inspectRootKeyMaterial as inspectSiteKeyMaterial } from "./keyring.env.js";
+export { revealRootKeyMaterial as revealSiteKeyMaterial } from "./keyring.env.js";
+export { generateFileRootKey as generateFileSiteKey } from "./keyring.env.js";
+export { deriveFromRootKey as deriveFromSiteKey } from "./keyring.env.js";
+export { deriveSigningSecretFromRootKey as deriveSigningSecretFromSiteKey } from "./keyring.env.js";
+export type { RootKeyEnvironmentPort as SiteKeyEnvironmentPort } from "./keyring.env.js";
+export type { RootKeyRejection as SiteKeyRejection } from "./keyring.env.js";
+export type { ParsedRootKeyHex as ParsedSiteKeyHex } from "./keyring.env.js";
+export type { RootKeyStatus as SiteKeyStatus } from "./keyring.env.js";
+export type { RootKeyReveal as SiteKeyReveal } from "./keyring.env.js";
+export type { InspectRootKeyMaterialOptions as InspectSiteKeyMaterialOptions } from "./keyring.env.js";
+export type { GeneratedFileRootKey as GeneratedFileSiteKey } from "./keyring.env.js";
+/** @deprecated use SiteKeyHandle */
+export type { RootKeyHandle } from "./ports.js";
+/** @deprecated use FixedSiteKeyKeyring */
+export { FixedRootKeyKeyring } from "./keyring.env.js";
+/** @deprecated use UnusableSiteKeyError */
+export { UnusableRootKeyError } from "./keyring.env.js";
+/** @deprecated use SiteKeyFileAlreadyExistsError */
+export { RootKeyFileAlreadyExistsError } from "./keyring.env.js";
+/** @deprecated use parseSiteKeyHex */
+export { parseRootKeyHex } from "./keyring.env.js";
+/** @deprecated use fingerprintSiteKeyHex */
+export { fingerprintRootKeyHex } from "./keyring.env.js";
+/** @deprecated use inspectSiteKeyMaterial */
+export { inspectRootKeyMaterial } from "./keyring.env.js";
+/** @deprecated use revealSiteKeyMaterial */
+export { revealRootKeyMaterial } from "./keyring.env.js";
+/** @deprecated use generateFileSiteKey */
+export { generateFileRootKey } from "./keyring.env.js";
+/** @deprecated use deriveFromSiteKey */
+export { deriveFromRootKey } from "./keyring.env.js";
+/** @deprecated use deriveSigningSecretFromSiteKey */
+export { deriveSigningSecretFromRootKey } from "./keyring.env.js";
+/** @deprecated use SiteKeyEnvironmentPort */
+export type { RootKeyEnvironmentPort } from "./keyring.env.js";
+/** @deprecated use SiteKeyRejection */
+export type { RootKeyRejection } from "./keyring.env.js";
+/** @deprecated use ParsedSiteKeyHex */
+export type { ParsedRootKeyHex } from "./keyring.env.js";
+/** @deprecated use SiteKeyStatus */
+export type { RootKeyStatus } from "./keyring.env.js";
+/** @deprecated use SiteKeyReveal */
+export type { RootKeyReveal } from "./keyring.env.js";
+/** @deprecated use InspectSiteKeyMaterialOptions */
+export type { InspectRootKeyMaterialOptions } from "./keyring.env.js";
+/** @deprecated use GeneratedFileSiteKey */
+export type { GeneratedFileRootKey } from "./keyring.env.js";
 export { formatAad } from "./aad.js";
 export { defaultPlatformMessages } from "../messages.js";
 export type { PlatformMessages } from "../messages.js";
+export * from "./credential-token.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/secrets/index.js

@@ -1,5 +1,36 @@
 export { AesGcmSecretSealer } from "./secret-sealer.aesgcm.js";
-export { EnvOrFileKeyring, FixedRootKeyKeyring, UnusableRootKeyError, RootKeyFileAlreadyExistsError, parseRootKeyHex, fingerprintRootKeyHex, inspectRootKeyMaterial, revealRootKeyMaterial, generateFileRootKey, deriveFromRootKey, deriveSigningSecretFromRootKey, } from "./keyring.env.js";
+export { EnvOrFileKeyring } from "./keyring.env.js";
+export { FixedRootKeyKeyring as FixedSiteKeyKeyring } from "./keyring.env.js"; // site-key-legacy: implementation binding; remove on/after 2026-11-01
+export { UnusableRootKeyError as UnusableSiteKeyError } from "./keyring.env.js"; // site-key-legacy: implementation binding; remove on/after 2026-11-01
+export { RootKeyFileAlreadyExistsError as SiteKeyFileAlreadyExistsError } from "./keyring.env.js"; // site-key-legacy: implementation binding; remove on/after 2026-11-01
+export { parseRootKeyHex as parseSiteKeyHex } from "./keyring.env.js"; // site-key-legacy: implementation binding; remove on/after 2026-11-01
+export { fingerprintRootKeyHex as fingerprintSiteKeyHex } from "./keyring.env.js"; // site-key-legacy: implementation binding; remove on/after 2026-11-01
+export { inspectRootKeyMaterial as inspectSiteKeyMaterial } from "./keyring.env.js"; // site-key-legacy: implementation binding; remove on/after 2026-11-01
+export { revealRootKeyMaterial as revealSiteKeyMaterial } from "./keyring.env.js"; // site-key-legacy: implementation binding; remove on/after 2026-11-01
+export { generateFileRootKey as generateFileSiteKey } from "./keyring.env.js"; // site-key-legacy: implementation binding; remove on/after 2026-11-01
+export { deriveFromRootKey as deriveFromSiteKey } from "./keyring.env.js"; // site-key-legacy: implementation binding; remove on/after 2026-11-01
+export { deriveSigningSecretFromRootKey as deriveSigningSecretFromSiteKey } from "./keyring.env.js"; // site-key-legacy: implementation binding; remove on/after 2026-11-01
+/** @deprecated use FixedSiteKeyKeyring */
+export { FixedRootKeyKeyring } from "./keyring.env.js"; // site-key-legacy: deprecated alias; remove on/after 2026-11-01
+/** @deprecated use UnusableSiteKeyError */
+export { UnusableRootKeyError } from "./keyring.env.js"; // site-key-legacy: deprecated alias; remove on/after 2026-11-01
+/** @deprecated use SiteKeyFileAlreadyExistsError */
+export { RootKeyFileAlreadyExistsError } from "./keyring.env.js"; // site-key-legacy: deprecated alias; remove on/after 2026-11-01
+/** @deprecated use parseSiteKeyHex */
+export { parseRootKeyHex } from "./keyring.env.js"; // site-key-legacy: deprecated alias; remove on/after 2026-11-01
+/** @deprecated use fingerprintSiteKeyHex */
+export { fingerprintRootKeyHex } from "./keyring.env.js"; // site-key-legacy: deprecated alias; remove on/after 2026-11-01
+/** @deprecated use inspectSiteKeyMaterial */
+export { inspectRootKeyMaterial } from "./keyring.env.js"; // site-key-legacy: deprecated alias; remove on/after 2026-11-01
+/** @deprecated use revealSiteKeyMaterial */
+export { revealRootKeyMaterial } from "./keyring.env.js"; // site-key-legacy: deprecated alias; remove on/after 2026-11-01
+/** @deprecated use generateFileSiteKey */
+export { generateFileRootKey } from "./keyring.env.js"; // site-key-legacy: deprecated alias; remove on/after 2026-11-01
+/** @deprecated use deriveFromSiteKey */
+export { deriveFromRootKey } from "./keyring.env.js"; // site-key-legacy: deprecated alias; remove on/after 2026-11-01
+/** @deprecated use deriveSigningSecretFromSiteKey */
+export { deriveSigningSecretFromRootKey } from "./keyring.env.js"; // site-key-legacy: deprecated alias; remove on/after 2026-11-01
 export { formatAad } from "./aad.js";
 export { defaultPlatformMessages } from "../messages.js";
+export * from "./credential-token.js";
 //# sourceMappingURL=index.js.map

package/dist/secrets/secret-sealer.aesgcm.d.ts

@@ -2,8 +2,14 @@ import type { KeyringPort, RootKeyHandle, SecretSealerPort } from "./ports.js";
 import type { SealedSecret } from "./types.js";
 export declare class AesGcmSecretSealer implements SecretSealerPort {
     private readonly keyring;
+    private readonly randomBytesFn;
+    /** Inject randomness for wire fixtures; production uses Node's CSPRNG for every fresh IV. */
     constructor({ keyring }: {
         keyring: KeyringPort;
+    }, optional?: {
+        randomBytesFn?: (input: {
+            byteLength: number;
+        }) => Uint8Array;
     });
     /** Encrypts under the requested generation with a fresh IV; AAD must be reconstructed on open. */
     seal(input: {

package/dist/secrets/secret-sealer.aesgcm.js

@@ -14,13 +14,20 @@ export class AesGcmSecretSealer {
     // Root keys stay behind handles, and the purpose separates this HKDF domain from signing/tokens.
     // Exercise real GCM with an in-memory keyring: a plaintext fake would miss authentication failures.
     keyring;
-    constructor({ keyring }) { this.keyring = keyring; }
+    randomBytesFn;
+    /** Inject randomness for wire fixtures; production uses Node's CSPRNG for every fresh IV. */
+    constructor({ keyring }, optional = {}) {
+        this.keyring = keyring;
+        this.randomBytesFn = optional.randomBytesFn ?? (({ byteLength }) => randomBytes(byteLength));
+    }
     /** Encrypts under the requested generation with a fresh IV; AAD must be reconstructed on open. */
     async seal(input) {
         if (typeof input.aad !== "string")
             throw new TypeError("AesGcmSecretSealer: aad must be a string");
         const aesKey = await this.deriveAesKey(input.key);
-        const iv = randomBytes(IV_LENGTH_BYTES);
+        const iv = Buffer.from(this.randomBytesFn({ byteLength: IV_LENGTH_BYTES }));
+        if (iv.length !== IV_LENGTH_BYTES)
+            throw new TypeError("AesGcmSecretSealer: IV must contain exactly 12 bytes");
         // GCM must never reuse an IV under the same key. AAD is authenticated but not stored in the
         // envelope, so callers must reconstruct the byte-identical context when opening the record.
         const cipher = createCipheriv(ALG, aesKey, iv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/platform",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Generic OS/platform primitives: process exec and lifecycle, filesystem containment, HTTP readiness polling, toolchain discovery, blob storage, AWS signing, and an SSRF-safe asset cache.",
   "license": "Apache-2.0",
   "repository": {
@@ -25,7 +25,9 @@
       "./fs/durable-json": "node",
       "./fs": "node",
       "./net": "node",
-      "./fs/file-lock": "node"
+      "./net/endpoint-policy": "universal",
+      "./fs/file-lock": "node",
+      "./secrets/credential-token": "universal"
     }
   },
   "type": "module",
@@ -93,10 +95,20 @@
       "import": "./dist/net/index.js",
       "default": "./dist/net/index.js"
     },
+    "./net/endpoint-policy": {
+      "types": "./dist/net/endpoint-policy.d.ts",
+      "import": "./dist/net/endpoint-policy.js",
+      "default": "./dist/net/endpoint-policy.js"
+    },
     "./fs/file-lock": {
       "types": "./dist/fs/file-lock.d.ts",
       "import": "./dist/fs/file-lock.js",
       "default": "./dist/fs/file-lock.js"
+    },
+    "./secrets/credential-token": {
+      "types": "./dist/secrets/credential-token.d.ts",
+      "import": "./dist/secrets/credential-token.js",
+      "default": "./dist/secrets/credential-token.js"
     }
   },
   "files": [