@jini-ai/platform 0.1.2 → 0.5.0

package/dist/messages.js

@@ -0,0 +1,15 @@
+export const defaultPlatformMessages = {
+    atomicModeInvalid: () => "atomic file mode must be permission bits between 0000 and 0777",
+    atomicTempPathInvalid: () => "atomic temp path must be a different same-directory file",
+    atomicTempNameInvalid: () => "atomic temp name must be one safe segment",
+    atomicSymlinkRefused: () => "atomic write refused a symbolic-link destination",
+    atomicPermissionsRefused: () => "atomic write refused non-owner-only permissions",
+    atomicJsonUnserializable: () => "atomic JSON data must be serializable",
+    fileLockIntervalsInvalid: () => "file lock intervals must be positive safe integers (timeout may be zero; stale may be Infinity)",
+    fileLockWriteNoProgress: () => "file lock ownership write made no progress",
+    egressRefused: () => "egress to the requested host was refused by the outbound network policy",
+    rootKeySealedWarning: ({ subject }) => `IMPORTANT: anything sealed while ${subject} was in place was sealed under key material derived from these same bytes, `,
+    fileLockTimeout: ({ waitedMs }) => `exclusive file lock timed out after ${Math.round(waitedMs)}ms`,
+    fileLockLost: () => "exclusive file lock lost ownership before the critical section finished",
+};
+//# sourceMappingURL=messages.js.map

package/dist/net/address.d.ts

@@ -0,0 +1,38 @@
+/** Expand an IPv6 literal (with `::` compression and/or an embedded dotted
+ *  IPv4 tail) into its eight 16-bit groups, or null if it does not parse.
+ *  Node's URL parser normalizes mapped literals to hex (`::ffff:127.0.0.1` →
+ *  `::ffff:7f00:1`), so a string regex can't reliably spot the mapped range —
+ *  we have to canonicalize.
+ *
+ *  Exported (previously module-private) so its parse-failure guards are
+ *  directly unit-testable: the IP classifier and guarded client gate
+ *  calls behind `net.isIP(addr) === 6`, and Node's `isIP` already fully
+ *  validates IPv6 syntax (including embedded-IPv4-tail octet ranges) before
+ *  returning 6 — empirically re-verified this session by fuzzing ~10k
+ *  `isIP`-accepted v6 literals through this function's guards with zero
+ *  hits — so none of these guards are reachable through that path. They stay
+ *  as real defense-in-depth (fail closed with `null` rather than trust a
+ *  platform primitive never changing behavior), matching the asset cache's
+ *  exported-for-direct-testing precedent (`readBodyCapped`'s abort parameter). */
+export declare function expandIpv6({ address: addr }: {
+    address: string;
+}): number[] | null;
+/** True for any address an external CDN must never resolve to: loopback,
+ *  link-local, private, CGNAT, ULA, multicast, or unspecified. An unparseable
+ *  input is treated as unsafe. */
+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;
+/** 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;
+}, _optional?: Record<string, never>): boolean;
+//# sourceMappingURL=address.d.ts.map

package/dist/net/address.js

@@ -0,0 +1,241 @@
+import { isIP } from 'node:net';
+// SSRF peer classification is distinct from core's browser-development LAN origin allow-list.
+/** Expand an IPv6 literal (with `::` compression and/or an embedded dotted
+ *  IPv4 tail) into its eight 16-bit groups, or null if it does not parse.
+ *  Node's URL parser normalizes mapped literals to hex (`::ffff:127.0.0.1` →
+ *  `::ffff:7f00:1`), so a string regex can't reliably spot the mapped range —
+ *  we have to canonicalize.
+ *
+ *  Exported (previously module-private) so its parse-failure guards are
+ *  directly unit-testable: the IP classifier and guarded client gate
+ *  calls behind `net.isIP(addr) === 6`, and Node's `isIP` already fully
+ *  validates IPv6 syntax (including embedded-IPv4-tail octet ranges) before
+ *  returning 6 — empirically re-verified this session by fuzzing ~10k
+ *  `isIP`-accepted v6 literals through this function's guards with zero
+ *  hits — so none of these guards are reachable through that path. They stay
+ *  as real defense-in-depth (fail closed with `null` rather than trust a
+ *  platform primitive never changing behavior), matching the asset cache's
+ *  exported-for-direct-testing precedent (`readBodyCapped`'s abort parameter). */
+export function expandIpv6({ address: addr }) {
+    // `String#split` always returns a non-empty array, so index 0 is never
+    // `undefined` — the `!` narrows a `noUncheckedIndexedAccess` false
+    // positive, not a real fallback path.
+    let s = addr.toLowerCase().split('%')[0];
+    if (!s.includes(':'))
+        return null;
+    // Fold a trailing dotted IPv4 (`…:1.2.3.4`) into two hex groups.
+    const v4 = /^(.*:)(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/.exec(s);
+    if (v4) {
+        // `v4[2]` is the regex's second (mandatory, non-optional) capture group
+        // of a successful match — always defined.
+        const o = v4[2].split('.').map((n) => Number(n));
+        if (o.length !== 4 || o.some((n) => !Number.isInteger(n) || n < 0 || n > 255))
+            return null;
+        // `o` is now a validated 4-element array — indices 0-3 always defined.
+        const hi = (((o[0] << 8) | o[1])).toString(16);
+        const lo = (((o[2] << 8) | o[3])).toString(16);
+        s = `${v4[1]}${hi}:${lo}`;
+    }
+    const halves = s.split('::');
+    if (halves.length > 2)
+        return null;
+    const parse = (p) => p === '' ? [] : p.split(':').map((g) => (/^[0-9a-f]{1,4}$/.test(g) ? parseInt(g, 16) : Number.NaN));
+    // `halves` always has at least one element (split guarantee).
+    const left = parse(halves[0]);
+    let groups;
+    if (halves.length === 1) {
+        groups = left;
+    }
+    else {
+        // `halves.length === 2` here (the `> 2` case already returned above).
+        const right = parse(halves[1]);
+        const fill = 8 - left.length - right.length;
+        if (fill < 1)
+            return null;
+        groups = [...left, ...new Array(fill).fill(0), ...right];
+    }
+    if (groups.length !== 8 || groups.some((g) => Number.isNaN(g) || g < 0 || g > 0xffff))
+        return null;
+    return groups;
+}
+/** True for any address an external CDN must never resolve to: loopback,
+ *  link-local, private, CGNAT, ULA, multicast, or unspecified. An unparseable
+ *  input is treated as unsafe. */
+export function isPrivateAddress({ address: addr }) {
+    const fam = isIP(addr);
+    if (fam === 4) {
+        // `net.isIP(addr) === 4` already guarantees `addr` is a syntactically
+        // valid dotted-quad with four 0-255 decimal octets (no leading-zero
+        // octal ambiguity, no out-of-range component) — empirically re-verified
+        // this session by fuzzing 500k+ candidate strings through `isIP` and
+        // this same re-derivation with zero divergences. `o` is therefore always
+        // a validated 4-element array.
+        const o = addr.split('.').map((n) => Number(n));
+        const a = o[0];
+        const b = o[1];
+        if (a === 0)
+            return true; // "this" network / unspecified
+        if (a === 10)
+            return true; // private
+        if (a === 127)
+            return true; // loopback
+        if (a === 169 && b === 254)
+            return true; // link-local
+        if (a === 172 && b >= 16 && b <= 31)
+            return true; // private
+        if (a === 192 && b === 168)
+            return true; // private
+        if (a === 100 && b >= 64 && b <= 127)
+            return true; // CGNAT
+        if (a >= 224)
+            return true; // multicast + reserved
+        return false;
+    }
+    if (fam === 6) {
+        const groups = expandIpv6({ address: addr });
+        // `net.isIP(addr) === 6` already guarantees `addr` is syntactically valid
+        // IPv6 (Node validates this before classifying the family), and
+        // `expandIpv6` implements the same canonicalization Node's own parser
+        // does, so it never returns `null` for an `isIP`-accepted literal —
+        // empirically re-verified this session by fuzzing ~10k `isIP`-accepted
+        // v6 literals through `expandIpv6` with zero `null` results (see
+        // `expandIpv6`'s doc comment and `archived provenance ledger`'s 2026-07-22 entry).
+        // Kept as a real fail-closed guard (defense-in-depth against a future
+        // change to either parser) rather than asserted away, so it stays
+        // provably-unreachable-but-intentional instead of a forced test.
+        if (!groups)
+            return true; // can't canonicalize a "valid" v6 → refuse
+        // IPv4-mapped (`::ffff:0:0/96`) and the deprecated IPv4-compatible
+        // (`::0:0/96`, excluding :: / ::1) carry an embedded IPv4 — classify it by
+        // its real v4 range so `::ffff:7f00:1` (== 127.0.0.1) is caught.
+        const topZero = groups.slice(0, 5).every((g) => g === 0);
+        if (topZero && (groups[5] === 0xffff || groups[5] === 0)) {
+            // `groups` is a validated 8-element array once non-null — indices 6-7
+            // always defined.
+            const a = groups[6] >> 8;
+            const b = groups[6] & 0xff;
+            const c = groups[7] >> 8;
+            const d = groups[7] & 0xff;
+            if (groups[5] === 0xffff || a !== 0 || b !== 0) {
+                return isPrivateAddress({ address: `${a}.${b}.${c}.${d}` });
+            }
+        }
+        if (groups.every((g) => g === 0))
+            return true; // ::  (unspecified)
+        if (groups.slice(0, 7).every((g) => g === 0) && groups[7] === 1)
+            return true; // ::1 loopback
+        const first = groups[0];
+        if ((first & 0xffc0) === 0xfe80)
+            return true; // link-local fe80::/10 (fe80–febf)
+        if ((first & 0xfe00) === 0xfc00)
+            return true; // unique-local fc00::/7
+        if ((first & 0xff00) === 0xff00)
+            return true; // multicast ff00::/8
+        return false;
+    }
+    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));
+}
+/** 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 || '')
+        .toLowerCase()
+        .replace(/^\[|\]$/g, '')
+        .replace(/\.$/, '');
+    if (normalized === 'localhost')
+        return true;
+    if (normalized === '::1' || normalized === '0:0:0:0:0:0:0:1')
+        return true;
+    if (isIP(normalized) === 4)
+        return normalized === '127.0.0.1' || normalized.startsWith('127.');
+    return false;
+}
+//# sourceMappingURL=address.js.map

package/dist/net/index.d.ts

@@ -0,0 +1,2 @@
+export { isPrivateAddress, expandIpv6, isLoopbackApiHost, isBlockedExternalApiHostname, isLoopbackHostname } from "./address.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/net/index.js

@@ -0,0 +1,2 @@
+export { isPrivateAddress, expandIpv6, isLoopbackApiHost, isBlockedExternalApiHostname, isLoopbackHostname } from "./address.js";
+//# sourceMappingURL=index.js.map

package/dist/process.d.ts

@@ -141,7 +141,8 @@ export declare function waitForProcessExit(pid: number | null | undefined, timeo
 export declare function listProcessSnapshots(): Promise<ProcessSnapshot[]>;
 /**
  * Collect the transitive set of descendant PIDs (including the roots) from a
- * process snapshot list, returned sorted descending so children precede parents.
+ * process snapshot list, returned sorted by numeric PID descending for deterministic ordering.
+ * PID reuse and wraparound mean this does not guarantee children precede parents.
  *
  * @param processes - The full process snapshot list to walk.
  * @param rootPids - The root PIDs whose subtrees to collect (non-numbers ignored).

package/dist/process.js

@@ -285,7 +285,8 @@ export async function listProcessSnapshots() {
 }
 /**
  * Collect the transitive set of descendant PIDs (including the roots) from a
- * process snapshot list, returned sorted descending so children precede parents.
+ * process snapshot list, returned sorted by numeric PID descending for deterministic ordering.
+ * PID reuse and wraparound mean this does not guarantee children precede parents.
  *
  * @param processes - The full process snapshot list to walk.
  * @param rootPids - The root PIDs whose subtrees to collect (non-numbers ignored).

package/dist/proxy-env.js

@@ -365,7 +365,7 @@ export function resolveSystemProxyEnv(options = {}) {
         // `RegExp` construction from untrusted input. Empirically re-verified
         // this session: 200k fuzzed `stdout`/registry-value strings (control
         // characters, huge lengths, null bytes) through both parse functions,
-        // zero throws — see source-map.md's 2026-07-22 entry.
+        // zero throws — see archived provenance ledger's 2026-07-22 entry.
         return {};
     }
     return {};

package/dist/resource-paths.js

@@ -10,7 +10,7 @@
  * Generalized from an upstream flat daemon module: every hardcoded env-var
  * name, the host CLI's own package specifier, the default data-directory
  * name, and the Windows packaged-resources marker segment are now fields on
- * {@link ResourcePathsConfig} — see `source-map.md` for the exact mapping.
+ * {@link ResourcePathsConfig} — see `archived provenance ledger` for the exact mapping.
  */
 import fs from 'node:fs';
 import { createRequire } from 'node:module';

package/dist/sandbox-env.d.ts

@@ -1,7 +1,7 @@
 /**
  * Names the environment variables and on-disk naming this port reads/writes.
  * A consumer supplies its own env-var names and config-directory name — see
- * `source-map.md` for the values a real adapter (e.g. the OD adapter) uses.
+ * `archived provenance ledger` for the values a real adapter (e.g. the OD adapter) uses.
  */
 export interface SandboxEnvConfig {
     /** Env var gating whether sandboxing is on (truthy/falsy string). */

package/dist/sandbox-env.js

@@ -10,7 +10,7 @@
  * Generalized from an upstream flat daemon module: the origin hardcoded its
  * host product's env-var names and a product-branded config sub-directory.
  * Every one of those is now a field on {@link SandboxEnvConfig} so a
- * consumer isn't branded — see `source-map.md` for the exact mapping.
+ * consumer isn't branded — see `archived provenance ledger` for the exact mapping.
  */
 import fs from 'node:fs';
 import path from 'node:path';

package/dist/secrets/aad.d.ts

@@ -0,0 +1,7 @@
+/** Formats an existing colon-separated AAD lineage without escaping or changing its bytes. */
+export declare function formatAad({ kind, version, parts }: {
+    kind: string;
+    version: string;
+    parts: readonly string[];
+}): string;
+//# sourceMappingURL=aad.d.ts.map

package/dist/secrets/aad.js

@@ -0,0 +1,5 @@
+/** Formats an existing colon-separated AAD lineage without escaping or changing its bytes. */
+export function formatAad({ kind, version, parts }) {
+    return [kind, version, ...parts].join(":");
+}
+//# sourceMappingURL=aad.js.map

package/dist/secrets/credential-sets/aad.d.ts

@@ -0,0 +1,7 @@
+/** Stable v1 AAD binding workspace, vendor, and credential identity. */
+export declare function buildVendorCredentialAad(input: {
+    workspaceId: string;
+    vendorId: string;
+    id: string;
+}): string;
+//# sourceMappingURL=aad.d.ts.map

package/dist/secrets/credential-sets/aad.js

@@ -0,0 +1,7 @@
+import { formatAad } from "../aad.js";
+const AAD_VERSION = "v1";
+/** Stable v1 AAD binding workspace, vendor, and credential identity. */
+export function buildVendorCredentialAad(input) {
+    return formatAad({ kind: "vendor-credential-set", version: AAD_VERSION, parts: [input.workspaceId, input.vendorId, input.id] });
+}
+//# sourceMappingURL=aad.js.map

package/dist/secrets/credential-sets/index.d.ts

@@ -0,0 +1,4 @@
+export type { VendorCredentialSetRecord, VendorCredentialSetSummary, VendorCredentialSetRepoPort } from "./types.js";
+export { buildVendorCredentialAad } from "./aad.js";
+export { InMemoryVendorCredentialSetRepo } from "./repo.memory.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/secrets/credential-sets/index.js

@@ -0,0 +1,3 @@
+export { buildVendorCredentialAad } from "./aad.js";
+export { InMemoryVendorCredentialSetRepo } from "./repo.memory.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,36 @@
+import type { VendorCredentialSetRecord, VendorCredentialSetRepoPort } from "./types.js";
+/** In-memory repository preserving label uniqueness and group default promotion. */
+export declare class InMemoryVendorCredentialSetRepo implements VendorCredentialSetRepoPort {
+    constructor(_required: Record<string, never>);
+    private readonly rows;
+    private static rowKey;
+    private assertLabelAvailable;
+    private clearOtherDefaults;
+    insert(record: VendorCredentialSetRecord): Promise<void>;
+    update(record: VendorCredentialSetRecord): Promise<void>;
+    findById(input: {
+        workspaceId: string;
+        id: string;
+    }): Promise<VendorCredentialSetRecord | null>;
+    findDefaultByVendor(input: {
+        workspaceId: string;
+        vendorId: string;
+    }): Promise<VendorCredentialSetRecord | null>;
+    listByVendor(input: {
+        workspaceId: string;
+        vendorId: string;
+    }): Promise<VendorCredentialSetRecord[]>;
+    listByWorkspace(input: {
+        workspaceId: string;
+    }): Promise<VendorCredentialSetRecord[]>;
+    delete(input: {
+        workspaceId: string;
+        id: string;
+    }): Promise<void>;
+    updateAccountLabel(input: {
+        workspaceId: string;
+        id: string;
+        accountLabel: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=repo.memory.d.ts.map

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

@@ -0,0 +1,72 @@
+/** In-memory repository preserving label uniqueness and group default promotion. */
+export class InMemoryVendorCredentialSetRepo {
+    constructor(_required) { }
+    rows = new Map();
+    static rowKey(workspaceId, id) {
+        return `${workspaceId}::${id}`;
+    }
+    assertLabelAvailable(workspaceId, vendorId, label, excludingId) {
+        for (const row of this.rows.values()) {
+            if (row.workspaceId !== workspaceId || row.vendorId !== vendorId || row.label !== label)
+                continue;
+            if (excludingId !== undefined && row.id === excludingId)
+                continue;
+            throw new Error(`UNIQUE constraint failed: vendor_credential_sets.workspace_id, vendor_credential_sets.vendor_id, vendor_credential_sets.label`);
+        }
+    }
+    clearOtherDefaults(workspaceId, vendorId, keepId) {
+        for (const [key, row] of this.rows) {
+            if (row.workspaceId !== workspaceId || row.vendorId !== vendorId || row.id === keepId || !row.isDefault)
+                continue;
+            this.rows.set(key, { ...row, isDefault: false });
+        }
+    }
+    async insert(record) {
+        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) {
+        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) {
+        return this.rows.get(InMemoryVendorCredentialSetRepo.rowKey(input.workspaceId, input.id)) ?? null;
+    }
+    async findDefaultByVendor(input) {
+        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) {
+        return [...this.rows.values()].filter((row) => row.workspaceId === input.workspaceId && row.vendorId === input.vendorId);
+    }
+    async listByWorkspace(input) {
+        return [...this.rows.values()].filter((row) => row.workspaceId === input.workspaceId);
+    }
+    async delete(input) {
+        const key = InMemoryVendorCredentialSetRepo.rowKey(input.workspaceId, input.id);
+        const removed = this.rows.get(key);
+        this.rows.delete(key);
+        if (!removed?.isDefault)
+            return;
+        const remaining = [...this.rows.values()].filter((row) => row.workspaceId === removed.workspaceId && row.vendorId === removed.vendorId);
+        if (remaining.length === 0)
+            return;
+        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) {
+        const key = InMemoryVendorCredentialSetRepo.rowKey(input.workspaceId, input.id);
+        const existing = this.rows.get(key);
+        if (!existing)
+            return;
+        this.rows.set(key, { ...existing, accountLabel: input.accountLabel });
+    }
+}
+//# sourceMappingURL=repo.memory.js.map

package/dist/secrets/credential-sets/types.d.ts

@@ -0,0 +1,67 @@
+/** Host-neutral credential records and workspace-scoped repository contracts.
+ * insert/update clear other defaults in the same vendor group; deleting a default promotes
+ * the most recently updated remaining row. Summaries never include sealed payloads.
+ */
+import type { SealedSecret } from "../types.js";
+export interface VendorCredentialSetRecord {
+    readonly workspaceId: string;
+    readonly id: string;
+    /** Open string so plugin hosts can declare vendors beyond the built-in validators. */
+    readonly vendorId: string;
+    readonly label: string;
+    readonly sealed: SealedSecret;
+    /** Last four secret characters for recognition, stored in clear; a suffix alone is not the token. */
+    readonly tokenTail: string;
+    /** At most one default per (workspaceId, vendorId), maintained by the store/repository write path. */
+    readonly isDefault: boolean;
+    /** Only a verified public login belongs here; null until verification populates it. */
+    readonly accountLabel: string | null;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export interface VendorCredentialSetSummary {
+    readonly id: string;
+    readonly vendorId: string;
+    readonly label: string;
+    readonly configured: true;
+    readonly isDefault: boolean;
+    readonly tokenTail: string;
+    readonly accountLabel: string | null;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export interface VendorCredentialSetRepoPort {
+    insert(record: VendorCredentialSetRecord): Promise<void>;
+    /** Full-row replacement supports rename and secret rotation; label uniqueness can still reject it. */
+    update(record: VendorCredentialSetRecord): Promise<void>;
+    findById(input: {
+        workspaceId: string;
+        id: string;
+    }): Promise<VendorCredentialSetRecord | null>;
+    findDefaultByVendor(input: {
+        workspaceId: string;
+        vendorId: string;
+    }): Promise<VendorCredentialSetRecord | null>;
+    /** Lets the store recognize a group's first row and choose a promotion candidate before deletion. */
+    listByVendor(input: {
+        workspaceId: string;
+        vendorId: string;
+    }): Promise<VendorCredentialSetRecord[]>;
+    /** Intentionally unpaginated for a human-managed connection list, rather than a bulk credential inventory. */
+    listByWorkspace(input: {
+        workspaceId: string;
+    }): Promise<VendorCredentialSetRecord[]>;
+    /** Missing (workspaceId, id) is a no-op so repeated deletes remain idempotent. */
+    delete(input: {
+        workspaceId: string;
+        id: string;
+    }): Promise<void>;
+    /** Target only accountLabel: verification must not rewrite sealed/default/tail/updatedAt state.
+     * A missing row is a no-op, as with delete. */
+    updateAccountLabel(input: {
+        workspaceId: string;
+        id: string;
+        accountLabel: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/secrets/credential-sets/types.js

@@ -0,0 +1,6 @@
+/** Host-neutral credential records and workspace-scoped repository contracts.
+ * insert/update clear other defaults in the same vendor group; deleting a default promotes
+ * the most recently updated remaining row. Summaries never include sealed payloads.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/secrets/index.d.ts

@@ -0,0 +1,9 @@
+export type { SealedSecret } from "./types.js";
+export type { RootKeyHandle, 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 { formatAad } from "./aad.js";
+export { defaultPlatformMessages } from "../messages.js";
+export type { PlatformMessages } from "../messages.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/secrets/index.js

@@ -0,0 +1,5 @@
+export { AesGcmSecretSealer } from "./secret-sealer.aesgcm.js";
+export { EnvOrFileKeyring, FixedRootKeyKeyring, UnusableRootKeyError, RootKeyFileAlreadyExistsError, parseRootKeyHex, fingerprintRootKeyHex, inspectRootKeyMaterial, revealRootKeyMaterial, generateFileRootKey, deriveFromRootKey, deriveSigningSecretFromRootKey, } from "./keyring.env.js";
+export { formatAad } from "./aad.js";
+export { defaultPlatformMessages } from "../messages.js";
+//# sourceMappingURL=index.js.map