@jini-ai/platform 0.6.11 → 0.6.15-rc.1

package/dist/process.js

@@ -7,12 +7,14 @@
  * Windows `Get-CimInstance`), walk a process tree, and stop a set of PIDs with
  * SIGTERM-then-SIGKILL escalation.
  *
- * Depends on the `command` module for invocation construction; keeps a private
- * `errorCode` copy so it owns no cross-module runtime surface.
+ * Uses `command` for invocation construction and `shell`'s direct buffered
+ * executor for bounded usage samples; keeps a private `errorCode` copy.
  */
 import { execFile, spawn } from "node:child_process";
+import { posix, win32 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { createCommandInvocation } from "./command.js";
+import { execFileBuffered } from "./shell.js";
 /** @internal Extract a Node `error.code` as a string, or `null` when the value carries no code. */
 function errorCode(error) {
     if (typeof error !== "object" || error == null || !("code" in error))
@@ -285,6 +287,87 @@ export async function listProcessSnapshots() {
         return [];
     }
 }
+/** @internal Decode ps cumulative CPU time, including macOS fractional seconds and days. */
+function parseCpuTime(value) {
+    const match = value.match(/^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+(?:\.\d+)?)$/);
+    if (!match)
+        return NaN;
+    return Number(match[1] ?? 0) * 86400 + Number(match[2] ?? 0) * 3600
+        + Number(match[3]) * 60 + Number(match[4]);
+}
+/** @internal Reject incomplete metrics instead of presenting missing usage as zero. */
+function validProcessUsage(usage) {
+    const { pid, ppid, rssBytes, cpuSeconds } = usage;
+    return [pid, ppid].every(Number.isSafeInteger) && [rssBytes, cpuSeconds].every(Number.isFinite)
+        && [pid, ppid, rssBytes, cpuSeconds].every((value) => value >= 0);
+}
+/** @internal Read only comm, never args/command, so credentials cannot enter the result. */
+function parsePsUsage(stdout) {
+    return stdout.split(/\r?\n/).flatMap((line) => {
+        const match = line.match(/^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(\S.*)$/);
+        if (!match)
+            return [];
+        const usage = {
+            pid: Number(match[1]), ppid: Number(match[2]), rssBytes: Number(match[3]) * 1024,
+            cpuSeconds: parseCpuTime(match[4]), name: posix.basename(match[5].trim()),
+        };
+        return validProcessUsage(usage) ? [usage] : [];
+    });
+}
+/** @internal CIM serializes numeric fields as numbers or strings; null is not zero usage. */
+function cimNumber(value) {
+    if (typeof value === "number")
+        return value;
+    return typeof value === "string" && value.trim() ? Number(value) : NaN;
+}
+/** @internal Convert Windows 100ns CPU counters and retain nameless process rows. */
+function parseCimUsage(stdout) {
+    if (!stdout.trim())
+        return [];
+    const payload = JSON.parse(stdout);
+    return (Array.isArray(payload) ? payload : [payload]).flatMap((record) => {
+        if (!record || typeof record !== "object")
+            return [];
+        const row = record;
+        const usage = {
+            pid: cimNumber(row.ProcessId), ppid: cimNumber(row.ParentProcessId),
+            rssBytes: cimNumber(row.WorkingSetSize),
+            cpuSeconds: (cimNumber(row.UserModeTime) + cimNumber(row.KernelModeTime)) / 10_000_000,
+            name: typeof row.Name === "string" ? win32.basename(row.Name.trim()) : "",
+        };
+        return validProcessUsage(usage) ? [usage] : [];
+    });
+}
+/** @internal Fixed executable and argv, invoked directly without a command shell. */
+function processUsageCommand(windows) {
+    return windows
+        ? { command: "powershell.exe", args: ["-NoProfile", "-NonInteractive", "-Command",
+                "$ErrorActionPreference = 'Stop'; Get-CimInstance Win32_Process | Select-Object ProcessId, ParentProcessId, WorkingSetSize, UserModeTime, KernelModeTime, Name | ConvertTo-Json -Compress"] }
+        : { command: "ps", args: ["-axo", "pid=,ppid=,rss=,time=,comm="] };
+}
+/**
+ * Sample process RSS and cumulative CPU without reading command lines. Returns
+ * [] on command, timeout, buffer or JSON failure. RSS totals may count shared
+ * pages more than once; CPU percentages require deltas between samples.
+ * @param input - Optional host platform and bounded command-execution port.
+ * @param options - Execution timeout (default 5000ms); output is capped at 8MiB.
+ */
+export async function listProcessUsage(input = {}, options = {}) {
+    const windows = (input.platform ?? process.platform) === "win32";
+    const { command, args } = processUsageCommand(windows);
+    try {
+        const result = await (input.run ?? execFileBuffered)(command, args, {
+            encoding: "utf8", timeout: options.timeoutMs ?? 5000, maxBuffer: 8 * 1024 * 1024,
+            windowsHide: true,
+        });
+        if (!result.ok)
+            return [];
+        return windows ? parseCimUsage(result.stdout) : parsePsUsage(result.stdout);
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Collect the transitive set of descendant PIDs (including the roots) from a
  * process snapshot list, returned sorted by numeric PID descending for deterministic ordering.

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

@@ -24,10 +24,7 @@ export declare class InMemoryVaultRepo implements VaultRepoPort {
     /** O(n) memory scan, n stored rows; clones only the default, never its siblings. */
     findDefault(input: VaultDefaultQuery, _options?: VaultOptions): Promise<VaultRecord | null>;
     list(input: VaultQuery, _options?: VaultOptions): Promise<VaultRecord[]>;
-    put(input: {
-        record: VaultRecord;
-        expectedRevision: number | null;
-    }, _options?: VaultOptions): Promise<VaultRecord>;
+    put(input: Parameters<VaultRepoPort["put"]>[0], _options?: VaultOptions): Promise<VaultRecord>;
     /** Synchronous mutation owner shared with batch staging; default moves never re-seal. */
     private putRecord;
     patchMeta(input: {

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

@@ -81,7 +81,9 @@ export class InMemoryVaultRepo {
         const group = this.groupRows({ groupKey });
         if (group.some(row => row.id !== record.id && row.label === record.label))
             throw new VaultError({ code: "conflict" });
-        const saved = structuredClone({ ...record, isDefault: record.isDefault || group.length === 0 });
+        // Auto-select the first row so an ordinary save is usable without a separate default action.
+        // Explicit false opts out, keeping unattached project keys from becoming vendor defaults.
+        const saved = structuredClone({ ...record, isDefault: record.isDefault ?? (group.length === 0) });
         // Clear first, matching a SQL partial UNIQUE index; no transient duplicate default is required.
         if (saved.isDefault)
             this.clearDefaults({ group });

package/dist/secrets/credential-sets/vault.service.d.ts

@@ -1,5 +1,5 @@
 import type { KeyringPort, SecretSealerPort } from "../ports.js";
-import { type VaultContext, type VaultIdentity, type VaultMeta, type VaultMetaParsers, type VaultCopyResult, type VaultDefaultQuery, type VaultOptions, type VaultQuery, type VaultRecord, type VaultRepoPort, type VaultSummary } from "./vault.types.js";
+import { type VaultContext, type VaultIdentity, type VaultMeta, type VaultMetaParsers, type VaultCopyResult, type VaultDefaultQuery, type VaultOptions, type VaultQuery, type VaultPutRecord, type VaultRepoPort, type VaultSummary } from "./vault.types.js";
 export interface VaultServiceDeps {
     repo: VaultRepoPort;
     keyring: KeyringPort;
@@ -24,10 +24,10 @@ export interface VaultPutInput extends VaultContext {
      * Creation requires a payload (which may be null). Payloads are always sealed JSON.
      */
     payload?: VaultMeta | null | undefined;
-    /** Omitted preserves same-group default status; a provider move starts with false and the
-     * repository applies its first-row rule. Explicit true selects the destination default.
+    /** Omitted preserves same-group default status; creation/provider moves let the repository
+     * apply its first-row rule. Explicit false opts out; true selects the destination default.
      */
-    isDefault?: boolean;
+    isDefault?: boolean | undefined;
     /** A host-selected token, never a URI or serialized connection object. */
     hintToken?: string;
 }
@@ -50,6 +50,7 @@ export declare class SecretsVaultService {
     constructor(deps: VaultServiceDeps, _options?: VaultOptions);
     private authorize;
     private parse;
+    /** Resolve a matching identity; deletion can retain legacy metadata without interpreting it. */
     private find;
     private seal;
     private open;
@@ -61,14 +62,18 @@ export declare class SecretsVaultService {
      * Prepared records contain envelopes and stay private to the host, never a public read model.
      * @example const record = await vault.prepare(input); await repo.put({ record, expectedRevision: input.expectedRevision }); // inside the host transaction
      */
-    prepare(input: VaultPutInput, _options?: VaultOptions): Promise<VaultRecord>;
+    prepare(input: VaultPutInput, _options?: VaultOptions): Promise<VaultPutRecord>;
     /** Resolve the target identity and apply the service-level CAS precheck. */
     private findForPut;
     private parsePutMeta;
     /** Omitted payload keeps the existing envelope and hints without opening or sealing. */
     private putEnvelope;
-    /** Authorized runtime read; returns plaintext only to the caller that supplied exact ownership. */
-    get(input: VaultIdentity, _options?: VaultOptions): Promise<{
+    /** Authorized runtime read; returns plaintext only to the caller that supplied exact ownership.
+     * `provider`, when given, must match the row's group before its envelope is opened (a stale
+     * selection never decrypts another group's secret). */
+    get(input: VaultIdentity, { provider }?: {
+        provider?: string;
+    }): Promise<{
         summary: VaultSummary;
         payload: VaultMeta | null;
     } | null>;
@@ -103,7 +108,8 @@ export declare class SecretsVaultService {
     private copyRow;
     /** Guarded read of the source row, then a CAS write of the resealed target row. */
     private transferRow;
-    /** Overwrite keeps the target's default, revision chain and creation time. */
+    /** Overwrite keeps the target's default, revision chain and creation time. A new copy leaves
+     * placement unspecified, so the repo's first-row rule applies (never the source's default flag). */
     private writeCopy;
     /** Human-managed scoped inventory. No envelope or plaintext is opened or returned. */
     list(input: VaultQuery, _options?: VaultOptions): Promise<VaultSummary[]>;
@@ -116,7 +122,9 @@ export declare class SecretsVaultService {
     rotate(input: VaultIdentity & {
         expectedRevision: number;
     }, _options?: VaultOptions): Promise<VaultSummary>;
-    /** Idempotent for missing rows; existing rows require matching context and revision. */
+    /** Idempotent for missing rows; existing rows require matching context and revision.
+     * Deletion needs no metadata interpretation, so unupgraded legacy rows remain removable.
+     */
     delete(input: VaultIdentity & {
         expectedRevision: number;
     }, _options?: VaultOptions): Promise<boolean>;

package/dist/secrets/credential-sets/vault.service.js

@@ -81,13 +81,15 @@ export class SecretsVaultService {
         assertContext(record);
         return { ...record, meta: this.deps.metaParsers[record.kind]({ meta: record.meta, provider: record.provider }) };
     }
-    async find(input) {
+    /** Resolve a matching identity; deletion can retain legacy metadata without interpreting it. */
+    async find(input, { parseMeta = true } = {}) {
         const record = await this.deps.repo.find({ workspaceId: input.workspaceId, id: input.id });
         if (!record)
             return null;
         if (buildVaultAad(input) !== buildVaultAad(record))
             throw new VaultError({ code: "context" });
-        return this.parse(record);
+        assertContext(record);
+        return parseMeta ? this.parse(record) : record;
     }
     async seal(input) {
         if (input.payload === null)
@@ -137,7 +139,7 @@ export class SecretsVaultService {
         const { sealed, last4, tokenLength } = await this.putEnvelope({ input, identity, existing });
         const now = this.deps.now({});
         return { ...identity, provider: input.provider, label: input.label, meta, sealed,
-            isDefault: input.isDefault ?? (existing !== null && existing.provider === input.provider && existing.isDefault),
+            isDefault: input.isDefault ?? (existing !== null && existing.provider === input.provider ? existing.isDefault : undefined),
             revision: (input.expectedRevision ?? 0) + 1, last4, tokenLength,
             createdAt: existing === null ? now : existing.createdAt, updatedAt: now };
     }
@@ -174,11 +176,15 @@ export class SecretsVaultService {
             ? credentialTokenHint({ token: input.hintToken }) : null;
         return { sealed, last4: hint?.last4 ?? null, tokenLength: hint?.length ?? null };
     }
-    /** Authorized runtime read; returns plaintext only to the caller that supplied exact ownership. */
-    async get(input, _options = {}) {
+    /** Authorized runtime read; returns plaintext only to the caller that supplied exact ownership.
+     * `provider`, when given, must match the row's group before its envelope is opened (a stale
+     * selection never decrypts another group's secret). */
+    async get(input, { provider } = {}) {
         assertContext(input);
         await this.authorize({ action: "get", context: input });
         const record = await this.find(input);
+        if (record && provider !== undefined && record.provider !== provider)
+            throw new VaultError({ code: "context" });
         return record ? { summary: summary(record), payload: await this.open(record) } : null;
     }
     /** Singleton runtime read using one provider-independent lookup. Full expected ownership and
@@ -273,14 +279,15 @@ export class SecretsVaultService {
         const last4 = summary(await this.writeCopy({ source, record, targetIdentity, existing })).last4;
         return { status: "copied", ...(last4 ? { last4 } : {}) };
     }
-    /** Overwrite keeps the target's default, revision chain and creation time. */
+    /** Overwrite keeps the target's default, revision chain and creation time. A new copy leaves
+     * placement unspecified, so the repo's first-row rule applies (never the source's default flag). */
     async writeCopy({ source, record, targetIdentity, existing }) {
         if (existing && !isCompatibleOverwrite({ existing, record }))
             throw new VaultError({ code: "context" });
         const now = this.deps.now({});
         const placement = existing
             ? { isDefault: existing.isDefault, revision: existing.revision + 1, createdAt: existing.createdAt }
-            : { isDefault: false, revision: 1, createdAt: now };
+            : { isDefault: undefined, revision: 1, createdAt: now };
         const candidate = this.parse({ ...record, ...targetIdentity, ...placement, updatedAt: now });
         candidate.sealed = await this.seal({ context: targetIdentity, payload: await source.open(record) });
         // Reuse the source's hint policy without guessing a token field from a structured payload.
@@ -328,11 +335,13 @@ export class SecretsVaultService {
         return summary(this.parse(await this.deps.repo.put({ expectedRevision: input.expectedRevision,
             record: { ...existing, sealed, revision: existing.revision + 1, updatedAt: this.deps.now({}) } })));
     }
-    /** Idempotent for missing rows; existing rows require matching context and revision. */
+    /** Idempotent for missing rows; existing rows require matching context and revision.
+     * Deletion needs no metadata interpretation, so unupgraded legacy rows remain removable.
+     */
     async delete(input, _options = {}) {
         assertContext(input);
         await this.authorize({ action: "delete", context: input });
-        const existing = await this.find(input);
+        const existing = await this.find(input, { parseMeta: false });
         if (!existing)
             return false;
         if (existing.revision !== input.expectedRevision)

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

@@ -42,6 +42,12 @@ export interface VaultRecord extends VaultIdentity {
 export type VaultSummary = Omit<VaultRecord, "sealed"> & {
     configured: boolean;
 };
+/** Unspecified placement lets the repo auto-default a group's first row; false opts out.
+ * Persisted records and read models always contain a concrete boolean.
+ */
+export type VaultPutRecord = Omit<VaultRecord, "isDefault"> & {
+    isDefault?: boolean | undefined;
+};
 export interface VaultQuery {
     workspaceId: string;
     kind: VaultKind;
@@ -65,7 +71,7 @@ export interface VaultSingletonQuery {
 /** Ordered CAS operations; default side effects affect later operations' revisions. */
 export type VaultBatchOp = {
     put: {
-        record: VaultRecord;
+        record: VaultPutRecord;
         expectedRevision: number | null;
     };
 } | {
@@ -129,7 +135,7 @@ export interface VaultRepoPort {
     }, options?: VaultOptions): Promise<VaultBatchResult[]>;
     list(input: VaultQuery, options?: VaultOptions): Promise<VaultRecord[]>;
     put(input: {
-        record: VaultRecord;
+        record: VaultPutRecord;
         expectedRevision: number | null;
     }, options?: VaultOptions): Promise<VaultRecord>;
     /** Service-validated patch: top-level keys are plain JSON-path identifiers. */
@@ -148,11 +154,11 @@ export interface VaultRepoPort {
 }
 /** Unambiguous scope encoding keeps adapter default/identity checks on the same contract. */
 export declare function vaultGroupKey({ record }: {
-    record: VaultRecord;
+    record: VaultDefaultQuery;
 }, _options?: VaultOptions): string;
 /** Adapters guard CAS and immutable identity even for callers below the service. */
 export declare function assertVaultReplacement({ record, existing, expectedRevision }: {
-    record: VaultRecord;
+    record: VaultPutRecord;
     existing: VaultRecord | null;
     expectedRevision: number | null;
 }, _options?: VaultOptions): void;

package/dist/secrets/index.d.ts

@@ -1,6 +1,8 @@
 export type { SealedSecret } from "./types.js";
 export type { KeyringPort, SecretSealerPort } from "./ports.js";
 export { AesGcmSecretSealer } from "./secret-sealer.aesgcm.js";
+export { sealWithPassphrase, openWithPassphrase } from "./passphrase-envelope.js";
+export type { PassphraseEnvelopeOptions } from "./passphrase-envelope.js";
 export { EnvOrFileKeyring } from "./keyring.env.js";
 export type { EnvOrFileKeyringRequired, EnvOrFileKeyringOptions } from "./keyring.env.js";
 export type { RootKeyHandle as SiteKeyHandle } from "./ports.js";

package/dist/secrets/index.js

@@ -1,4 +1,5 @@
 export { AesGcmSecretSealer } from "./secret-sealer.aesgcm.js";
+export { sealWithPassphrase, openWithPassphrase } from "./passphrase-envelope.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

package/dist/secrets/passphrase-envelope.d.ts

@@ -0,0 +1,26 @@
+/** Optional randomness port for reproducible wire fixtures; production uses Node's CSPRNG. */
+export interface PassphraseEnvelopeOptions {
+    randomBytesFn?: (input: {
+        byteLength: number;
+    }) => Uint8Array;
+}
+/** Encrypts a UTF-8 payload (up to 16 MiB) into portable JSON, without host key material.
+ * Uses asynchronous scrypt and the existing sealer; performs no filesystem or environment I/O.
+ * Rejects invalid inputs or randomness. Passphrases are not normalized; only an empty one is refused,
+ * because sealing under "" turns the export into obfuscation (strength policy stays with the host).
+ * @complexity O(n + N*r*p) time and O(n + N*r) space for n payload bytes and bounded KDF costs.
+ */
+export declare function sealWithPassphrase({ payload, passphrase }: {
+    payload: string;
+    passphrase: string;
+}, options?: PassphraseEnvelopeOptions): Promise<string>;
+/** Authenticates a portable JSON envelope before returning its exact UTF-8 payload.
+ * Rejects malformed/oversized envelopes and unsupported KDF costs before deriving a key.
+ * Wrong passphrases and modified ciphertext/header reject without returning partial plaintext.
+ * @complexity O(n + N*r*p) time and O(n + N*r) space with fixed size and KDF ceilings.
+ */
+export declare function openWithPassphrase({ envelope, passphrase }: {
+    envelope: string;
+    passphrase: string;
+}, _options?: Record<string, never>): Promise<string>;
+//# sourceMappingURL=passphrase-envelope.d.ts.map

package/dist/secrets/passphrase-envelope.js

@@ -0,0 +1,125 @@
+import { randomBytes, scrypt } from "node:crypto";
+import { FixedRootKeyKeyring } from "./keyring.env.js";
+import { AesGcmSecretSealer } from "./secret-sealer.aesgcm.js";
+const FORMAT = "jini-passphrase-envelope";
+const HKDF_SALT = "jini-passphrase-envelope-v1";
+const MAX_PAYLOAD_BYTES = 16 * 1024 * 1024;
+const MAX_ENVELOPE_BYTES = 24 * 1024 * 1024;
+const SCRYPT_MAX_MEMORY = 128 * 1024 * 1024;
+/** Encrypts a UTF-8 payload (up to 16 MiB) into portable JSON, without host key material.
+ * Uses asynchronous scrypt and the existing sealer; performs no filesystem or environment I/O.
+ * Rejects invalid inputs or randomness. Passphrases are not normalized; only an empty one is refused,
+ * because sealing under "" turns the export into obfuscation (strength policy stays with the host).
+ * @complexity O(n + N*r*p) time and O(n + N*r) space for n payload bytes and bounded KDF costs.
+ */
+export async function sealWithPassphrase({ payload, passphrase }, options = {}) {
+    assertText(payload, MAX_PAYLOAD_BYTES);
+    assertText(passphrase, MAX_PAYLOAD_BYTES);
+    if (passphrase === "")
+        throw new TypeError("Passphrase envelope: passphrase must not be empty");
+    const randomBytesFn = options.randomBytesFn ?? (({ byteLength }) => randomBytes(byteLength));
+    const salt = Buffer.from(randomBytesFn({ byteLength: 16 }));
+    if (salt.length !== 16)
+        throw new TypeError("Passphrase envelope: salt must contain exactly 16 bytes");
+    const header = {
+        format: FORMAT, version: 1,
+        kdf: { name: "scrypt", salt: salt.toString("hex"), N: 32768, r: 8, p: 1 },
+    };
+    const keyring = await deriveKeyring({ passphrase, kdf: header.kdf });
+    const sealer = new AesGcmSecretSealer({ keyring }, { randomBytesFn });
+    const sealed = await sealer.seal({
+        plaintext: payload, key: await keyring.activeKey({}), aad: JSON.stringify(header),
+    });
+    return JSON.stringify({ header, sealed });
+}
+/** Authenticates a portable JSON envelope before returning its exact UTF-8 payload.
+ * Rejects malformed/oversized envelopes and unsupported KDF costs before deriving a key.
+ * Wrong passphrases and modified ciphertext/header reject without returning partial plaintext.
+ * @complexity O(n + N*r*p) time and O(n + N*r) space with fixed size and KDF ceilings.
+ */
+export async function openWithPassphrase({ envelope, passphrase }, _options = {}) {
+    assertText(passphrase, MAX_PAYLOAD_BYTES);
+    const parsed = parseEnvelope({ envelope });
+    const keyring = await deriveKeyring({ passphrase, kdf: parsed.header.kdf });
+    const sealer = new AesGcmSecretSealer({ keyring });
+    try {
+        return await sealer.open({ sealed: parsed.sealed }, { aad: JSON.stringify(parsed.header) });
+    }
+    catch {
+        // Never include the passphrase, payload, or crypto-library error context in recovery errors.
+        throw new Error("Passphrase envelope: authentication failed");
+    }
+}
+/** The format fixes r/p and accepts only bounded power-of-two N costs, preventing KDF DoS.
+ * The full header is AAD, including additional fields, so metadata cannot be silently modified.
+ */
+function parseEnvelope({ envelope }) {
+    assertText(envelope, MAX_ENVELOPE_BYTES);
+    let parsed;
+    try {
+        parsed = JSON.parse(envelope);
+    }
+    catch {
+        throw new TypeError("Passphrase envelope: invalid JSON");
+    }
+    if (!isRecord(parsed) || !isRecord(parsed.header))
+        throw invalidEnvelope();
+    if (parsed.header.format !== FORMAT || parsed.header.version !== 1)
+        throw invalidEnvelope();
+    assertKdf(parsed.header.kdf);
+    assertSealed(parsed.sealed);
+    return parsed;
+}
+function assertKdf(kdf) {
+    if (!isRecord(kdf))
+        throw invalidEnvelope();
+    if (kdf.name !== "scrypt" || typeof kdf.salt !== "string")
+        throw invalidEnvelope();
+    if (!/^[a-f0-9]{32}$/i.test(kdf.salt))
+        throw invalidEnvelope();
+    if (![16384, 32768, 65536].includes(kdf.N) || kdf.r !== 8 || kdf.p !== 1) {
+        throw invalidEnvelope();
+    }
+}
+function assertSealed(sealed) {
+    if (!isRecord(sealed))
+        throw invalidEnvelope();
+    if (sealed.alg !== "aes-256-gcm" || sealed.keyId !== "v1")
+        throw invalidEnvelope();
+    assertBase64(sealed.nonce, 12, 12);
+    assertBase64(sealed.ciphertext, 16, MAX_PAYLOAD_BYTES + 16);
+}
+function assertBase64(value, minBytes, maxBytes) {
+    if (typeof value !== "string")
+        throw invalidEnvelope();
+    const bytes = Buffer.from(value, "base64");
+    if (bytes.length < minBytes || bytes.length > maxBytes || bytes.toString("base64") !== value) {
+        throw invalidEnvelope();
+    }
+}
+function assertText(value, maxBytes) {
+    if (typeof value !== "string")
+        throw new TypeError("Passphrase envelope: expected a string");
+    if (Buffer.byteLength(value, "utf8") > maxBytes)
+        throw new RangeError("Passphrase envelope: size limit exceeded");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function invalidEnvelope() {
+    return new TypeError("Passphrase envelope: invalid or unsupported envelope");
+}
+/** scrypt supplies only a temporary root; the existing keyring owns HKDF domain separation. */
+async function deriveKeyring({ passphrase, kdf }) {
+    const root = await new Promise((resolve, reject) => {
+        scrypt(passphrase, Buffer.from(kdf.salt, "hex"), 32, { N: kdf.N, r: kdf.r, p: kdf.p, maxmem: SCRYPT_MAX_MEMORY }, (error, key) => error ? reject(error) : resolve(key));
+    });
+    try {
+        return new FixedRootKeyKeyring({ hex: root.toString("hex"), hkdfSalt: HKDF_SALT });
+    }
+    finally {
+        // The keyring copies the derived bytes; do not retain the temporary scrypt buffer as well.
+        root.fill(0);
+    }
+}
+//# sourceMappingURL=passphrase-envelope.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/platform",
-  "version": "0.6.11",
+  "version": "0.6.15-rc.1",
   "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": {
@@ -22,6 +22,7 @@
       "./secrets/testing": "node",
       "./http/guarded": "node",
       "./mail": "node",
+      "./mail/senders": "universal",
       "./mail/smtp": "node",
       "./fs/guarded-reader": "node",
       "./fs/durable-json": "node",
@@ -106,6 +107,11 @@
       "import": "./dist/mail/index.js",
       "default": "./dist/mail/index.js"
     },
+    "./mail/senders": {
+      "types": "./dist/mail/senders.d.ts",
+      "import": "./dist/mail/senders.js",
+      "default": "./dist/mail/senders.js"
+    },
     "./mail/smtp": {
       "types": "./dist/mail/smtp.d.ts",
       "import": "./dist/mail/smtp.js",
@@ -200,7 +206,7 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@jini-ai/core": "^0.6.11"
+    "@jini-ai/core": "^0.6.15-rc.1"
   },
   "publishConfig": {
     "access": "public",