@jini-ai/platform 0.5.2 → 0.5.4

package/dist/fs/verified-directory-move.js

@@ -0,0 +1,138 @@
+import { stageVerifiedFileRelocation } from "./verified-file-relocation.js";
+import fs from "node:fs";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+/** Fingerprint relative names, entry kinds, symlink targets and file bytes without following links.
+ * This is verification, never a log of file contents. Lease files are excluded by the host.
+ * @complexity O(bytes + entries log entries), O(entries + a fixed 64 KiB read buffer) space.
+ */
+export function directoryFingerprint({ dir }, { excluded = [], filesystem = fs } = {}) {
+    const digest = createHash("sha256");
+    function visit(relative) {
+        for (const entry of filesystem.readdirSync(path.join(dir, relative), { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            if (!relative && excluded.includes(entry.name))
+                continue;
+            const name = path.join(relative, entry.name), absolute = path.join(dir, name);
+            const stat = filesystem.lstatSync(absolute);
+            const kind = stat.isSymbolicLink() ? "link" : stat.isDirectory() ? "directory" : stat.isFile() ? "file" : "unsupported";
+            if (kind === "unsupported")
+                throw new Error(`Cannot move special filesystem entry: ${name}`);
+            digest.update(JSON.stringify([name, kind, stat.mode & 0o777]));
+            if (kind === "directory")
+                visit(name);
+            else if (kind === "link")
+                digest.update(JSON.stringify(filesystem.readlinkSync(absolute)));
+            else {
+                const fileDigest = createHash("sha256"), buffer = Buffer.allocUnsafe(64 * 1024);
+                const descriptor = filesystem.openSync(absolute, "r");
+                try {
+                    let bytes;
+                    while ((bytes = filesystem.readSync(descriptor, buffer, 0, buffer.length, null)) > 0)
+                        fileDigest.update(buffer.subarray(0, bytes));
+                }
+                finally {
+                    filesystem.closeSync(descriptor);
+                }
+                digest.update(fileDigest.digest());
+            }
+        }
+    }
+    visit("");
+    return digest.digest("hex");
+}
+/** Move only into an absent target. Verify before registry commit or source deletion.
+ * EXDEV uses copy/verify/retire/commit; failure restores the source and removes only our new copy.
+ * Same-filesystem failures roll the rename back. Commit must atomically update the host registry.
+ * @complexity O(bytes + entries log entries), with two verification passes.
+ */
+export function moveDirectoryVerified({ from, to, commit }, { excluded = [], filesystem = fs, prepareDestination, relocateFiles, verifyFile, backupId = randomUUID } = {}) {
+    const source = filesystem.realpathSync(from);
+    const target = path.resolve(to);
+    if (target === source || target.startsWith(source + path.sep))
+        throw new Error("A directory cannot be moved into itself.");
+    try {
+        filesystem.lstatSync(target);
+        throw new Error(`Move target already exists: ${target}`);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const before = directoryFingerprint({ dir: source }, { excluded, filesystem });
+    let copied = false;
+    try {
+        filesystem.renameSync(source, target);
+    }
+    catch (error) {
+        if (error.code !== "EXDEV")
+            throw error;
+        filesystem.mkdirSync(target);
+        copied = true;
+        try {
+            // The host may reserve the empty destination before any commit marker or database is copied.
+            prepareDestination?.({ path: target });
+            filesystem.cpSync(source, target, { recursive: true, force: false, errorOnExist: true, preserveTimestamps: true, verbatimSymlinks: true,
+                filter: (candidate) => candidate === source || !excluded.includes(path.relative(source, candidate).split(path.sep)[0]),
+            });
+        }
+        catch (failure) {
+            filesystem.rmSync(target, { recursive: true });
+            throw failure;
+        }
+    }
+    let retiredSource;
+    let staged;
+    try {
+        if (directoryFingerprint({ dir: target }, { excluded, filesystem }) !== before)
+            throw new Error("Moved directory verification failed.");
+        if (relocateFiles) {
+            if (!verifyFile)
+                throw new Error("File relocation requires a verification port.");
+            staged = stageVerifiedFileRelocation({ groups: relocateFiles({ source, target }), verify: verifyFile }, { filesystem, backupId, backupCovered: ({ from }) => copied && path.resolve(from).startsWith(target + path.sep) });
+        }
+        if (copied) {
+            const backupRoot = path.join(path.dirname(source), `.relocation-${backupId()}-backup`);
+            const backup = path.join(backupRoot, path.basename(source));
+            if (filesystem.existsSync(backup))
+                throw new Error(`Move backup target already exists: ${backup}`);
+            // The EXDEV original becomes a recovery folder before catalog commit, never a second live
+            // site at the old path if cleanup fails. An interrupted apply leaves explicit backups.
+            filesystem.mkdirSync(backupRoot);
+            filesystem.renameSync(source, backup);
+            retiredSource = backup;
+            const fd = filesystem.openSync(backupRoot, "r");
+            try {
+                filesystem.fsyncSync(fd);
+            }
+            finally {
+                filesystem.closeSync(fd);
+            }
+        }
+        // Persist directory-name changes for same-filesystem renames as well as EXDEV retirement.
+        for (const directory of new Set([path.dirname(source), path.dirname(target)])) {
+            const fd = filesystem.openSync(directory, "r");
+            try {
+                filesystem.fsyncSync(fd);
+            }
+            finally {
+                filesystem.closeSync(fd);
+            }
+        }
+        commit();
+    }
+    catch (error) {
+        if (retiredSource)
+            filesystem.renameSync(retiredSource, source);
+        staged?.rollback();
+        if (copied)
+            filesystem.rmSync(target, { recursive: true });
+        else
+            filesystem.renameSync(target, source);
+        throw error;
+    }
+    // If deletion fails after commit, the verified target and registry remain usable; old DB live
+    // names were already retired before commit. Never roll back a registry whose commit succeeded.
+    staged?.finalize();
+    // Keep the retired EXDEV recovery folder; it is never a registered/live site path.
+}
+//# sourceMappingURL=verified-directory-move.js.map

package/dist/fs/verified-file-relocation.d.ts

@@ -0,0 +1,27 @@
+import fs from "node:fs";
+export interface VerifiedFileGroup {
+    from: string;
+    to: string;
+    sidecars: readonly string[];
+}
+/** Stage related files together while both directory identities are reserved by the host. Raw
+ * sources remain intact through inspection so even WAL/SHM bytes are retained. Verification opens only
+ * stopped databases through an injected read-only inspector; the filesystem owner never uses SQL.
+ * @complexity O(total bytes + verification cost), bounded memory via native file copies.
+ */
+export declare function stageVerifiedFileRelocation({ groups, verify }: {
+    groups: readonly VerifiedFileGroup[];
+    verify: (required: {
+        path: string;
+    }) => string;
+}, { filesystem, backupCovered, backupId }?: {
+    filesystem?: typeof fs;
+    backupCovered?: (required: {
+        from: string;
+    }) => boolean;
+    backupId?: () => string;
+}): {
+    rollback: () => void;
+    finalize: () => void;
+};
+//# sourceMappingURL=verified-file-relocation.d.ts.map

package/dist/fs/verified-file-relocation.js

@@ -0,0 +1,115 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+/** Stage related files together while both directory identities are reserved by the host. Raw
+ * sources remain intact through inspection so even WAL/SHM bytes are retained. Verification opens only
+ * stopped databases through an injected read-only inspector; the filesystem owner never uses SQL.
+ * @complexity O(total bytes + verification cost), bounded memory via native file copies.
+ */
+export function stageVerifiedFileRelocation({ groups, verify }, { filesystem = fs, backupCovered = () => false, backupId = randomUUID } = {}) {
+    const created = [], retired = [], markers = [], redundantBackups = [];
+    const backupSuffix = `.relocation-${backupId()}-backup`;
+    const copyExclusive = (from, to) => {
+        // Reserve before copying so a disk-full failure is still ours to clean up. COPYFILE_EXCL
+        // alone may create a partial file before throwing, which cannot be tracked after the fact.
+        const fd = filesystem.openSync(to, "wx");
+        created.push(to);
+        filesystem.closeSync(fd);
+        filesystem.copyFileSync(from, to);
+        const copied = filesystem.openSync(to, "r+");
+        try {
+            filesystem.fsyncSync(copied);
+        }
+        finally {
+            filesystem.closeSync(copied);
+        }
+        syncParent(to);
+    };
+    const syncParent = (file) => {
+        // Directory fsync persists retirement/marker ordering before the host commits its catalog.
+        const fd = filesystem.openSync(path.dirname(file), "r");
+        try {
+            filesystem.fsyncSync(fd);
+        }
+        finally {
+            filesystem.closeSync(fd);
+        }
+    };
+    const rollback = () => {
+        for (const item of [...retired].reverse()) {
+            filesystem.renameSync(item.backup, item.from);
+            syncParent(item.from);
+        }
+        for (const file of [...created].reverse()) {
+            filesystem.rmSync(file, { force: true });
+            syncParent(file);
+        }
+    };
+    try {
+        for (const group of groups) {
+            const pairs = ["", ...group.sidecars].filter((suffix) => filesystem.existsSync(group.from + suffix))
+                .map((suffix) => ({ from: group.from + suffix, to: group.to + suffix }));
+            for (const pair of pairs)
+                if (!filesystem.lstatSync(pair.from).isFile())
+                    throw new Error(`Database move requires a regular file: ${pair.from}`);
+            filesystem.mkdirSync(path.dirname(group.to), { recursive: true });
+            const moving = path.resolve(group.from) !== path.resolve(group.to);
+            // A directory rename already carries unchanged DB paths atomically; verify those bytes
+            // without copying them. For a file move the original inode becomes the sole backup after
+            // verification: another full destination backup doubles storage without rollback benefit.
+            // Cross-volume directory moves already retain the untouched original directory. A copied
+            // DB inside that destination needs no second full backup of the same bytes.
+            if (moving) {
+                const marker = group.from + ".home2-relocation.json";
+                const fd = filesystem.openSync(marker, "wx");
+                created.push(marker);
+                markers.push(marker);
+                try {
+                    filesystem.writeFileSync(fd, JSON.stringify({ to: group.to, backup: group.from + backupSuffix }));
+                    filesystem.fsyncSync(fd);
+                }
+                finally {
+                    filesystem.closeSync(fd);
+                }
+                syncParent(marker);
+            }
+            const before = verify({ path: group.from });
+            for (const pair of pairs) {
+                if (path.resolve(pair.from) === path.resolve(pair.to))
+                    continue;
+                // A destination collision aborts; never overwrite another site's data or an old move.
+                copyExclusive(pair.from, pair.to);
+            }
+            if (verify({ path: group.to }) !== before)
+                throw new Error(`Database row counts changed while moving ${path.basename(group.to)}.`);
+            // Retire old live names BEFORE commit. Finalization removes recovery markers and redundant copies covered by the retained original: a crash
+            // or cleanup failure cannot leave two independently writable database names after commit.
+            if (moving)
+                for (const pair of pairs) {
+                    const backup = pair.from + backupSuffix;
+                    if (filesystem.existsSync(backup))
+                        throw new Error(`Database backup target already exists: ${backup}`);
+                    filesystem.renameSync(pair.from, backup);
+                    retired.push({ from: pair.from, backup });
+                    if (backupCovered({ from: pair.from }))
+                        redundantBackups.push(backup);
+                    syncParent(pair.from);
+                }
+        }
+    }
+    catch (error) {
+        rollback();
+        throw error;
+    }
+    return { rollback, finalize: () => {
+            for (const backup of redundantBackups) {
+                filesystem.rmSync(backup);
+                syncParent(backup);
+            }
+            for (const marker of markers) {
+                filesystem.rmSync(marker);
+                syncParent(marker);
+            }
+        } };
+}
+//# sourceMappingURL=verified-file-relocation.js.map

package/dist/fs/workspace-directory.d.ts

@@ -0,0 +1,19 @@
+import type { DirectoryRecord } from "./directory-registry.js";
+/** Shared selection policy for CLI/dev hosts. A registry ID disambiguates adopted paths;
+ * a basename selects the home first. No initialized home site preserves the supplied fallback.
+ * @complexity O(n) registered/child directories and validation probes.
+ */
+export declare function selectWorkspaceDirectory({ home, entries, fallback, selected, roots, listDirectories, isInitialized }: {
+    home: string;
+    entries: readonly DirectoryRecord[];
+    fallback: string;
+    selected?: string | undefined;
+    roots?: readonly string[];
+    listDirectories: (required: {
+        root: string;
+    }) => readonly string[];
+    isInitialized: (required: {
+        path: string;
+    }) => boolean;
+}, _options?: {}): string;
+//# sourceMappingURL=workspace-directory.d.ts.map

package/dist/fs/workspace-directory.js

@@ -0,0 +1,23 @@
+import path from "node:path";
+/** Shared selection policy for CLI/dev hosts. A registry ID disambiguates adopted paths;
+ * a basename selects the home first. No initialized home site preserves the supplied fallback.
+ * @complexity O(n) registered/child directories and validation probes.
+ */
+export function selectWorkspaceDirectory({ home, entries, fallback, selected, roots = [home], listDirectories, isInitialized }, _options = {}) {
+    if (selected !== undefined) {
+        const byId = entries.find((entry) => entry.id === selected);
+        if (byId)
+            return byId.path;
+        const inHome = path.join(home, selected);
+        if (isInitialized({ path: inHome }))
+            return inHome;
+        const matches = [...new Set([...entries.filter((entry) => path.basename(entry.path) === selected).map((entry) => entry.path),
+                ...roots.filter((root) => root !== home).map((root) => path.join(root, selected)).filter((dir) => isInitialized({ path: dir }))])];
+        if (matches.length > 1)
+            throw new Error("More than one registered directory has this name. Select its registry ID.");
+        return matches[0] ?? path.join(path.dirname(fallback), selected);
+    }
+    const candidates = [...entries.filter((entry) => path.dirname(entry.path) === home).sort((a, b) => (b.lastOpened ? Date.parse(b.lastOpened) : 0) - (a.lastOpened ? Date.parse(a.lastOpened) : 0)).map((entry) => entry.path), ...roots.flatMap((root) => listDirectories({ root }))];
+    return candidates.find((dir) => isInitialized({ path: dir })) ?? fallback;
+}
+//# sourceMappingURL=workspace-directory.js.map

package/dist/index.d.ts

@@ -33,6 +33,7 @@
  */
 export type { CommandInvocation, CommandInvocationRequest } from "./command.js";
 export { createCommandInvocation, createPackageManagerInvocation } from "./command.js";
+export { omitEnvironmentKeys } from "./child-environment.js";
 export type { ResolveSystemProxyEnvOptions, SystemProxyCommandRunner } from "./proxy-env.js";
 export { mergeProxyAwareEnv, parseMacosScutilProxyOutput, parseWindowsInternetSettingsProxyOutput, resolveSystemProxyEnv, } from "./proxy-env.js";
 export type { ProcessSnapshot, ProcessStampContract, ProcessStampField, ProcessStampShape, SpawnProcessRequest, StampedProcessMatchCriteria, StopProcessesResult, } from "./process.js";
@@ -48,7 +49,7 @@ export { wellKnownUserToolchainBins } from "./toolchain.js";
 export type { BufferedCommandResult } from "./shell.js";
 export { execCommandViaLoginShell, execFileBuffered } from "./shell.js";
 export type { AssetCache, AssetCacheOptions, AssetCacheResult } from "./asset-cache.js";
-export { AssetCacheError, assertSafePublicUrl, assetCacheKey, assetCacheRewriteUrl, createAssetCache, createValidatingLookup, isCacheableExternalUrl, } from "./asset-cache.js";
+export { AssetCacheError, assertSafePublicUrl, assetCacheKey, assetCacheRewriteUrl, createAssetCache, createAssetCacheDispatcher, createValidatingLookup, isCacheableExternalUrl, } from "./asset-cache.js";
 export { expandHomePrefix, resolveProjectRelativePath } from "./home-expansion.js";
 export type { SandboxEnvConfig, SandboxRuntimeConfig, SandboxRuntimeRoots } from "./sandbox-env.js";
 export { applySandboxRuntimeEnv, ensureSandboxRuntimeDirs, isSandboxImportedProjectRootAllowed, isSandboxModeEnabled, resolveSandboxRuntimeConfig, resolveSandboxRuntimeConfigFromEnv, sandboxAgentProfilesConfigPath, sandboxImportAllowedRoots, sandboxImportedProjectRootUnavailableReason, } from "./sandbox-env.js";

package/dist/index.js

@@ -32,6 +32,7 @@
  * Filesystem/network storage and its SigV4 signing belong here, with no kernel SQL-port dependency.
  */
 export { createCommandInvocation, createPackageManagerInvocation } from "./command.js";
+export { omitEnvironmentKeys } from "./child-environment.js";
 export { mergeProxyAwareEnv, parseMacosScutilProxyOutput, parseWindowsInternetSettingsProxyOutput, resolveSystemProxyEnv, } from "./proxy-env.js";
 export { collectProcessTreePids, createProcessStampArgs, isProcessAlive, listProcessSnapshots, matchesProcessStamp, matchesStampedProcess, readFlagValue, readProcessStamp, readProcessStampFromCommand, spawnBackgroundProcess, spawnLoggedProcess, stopProcesses, waitForProcessExit, } from "./process.js";
 export { atomicCopyFile, pathContains, readLogTail, removePathBestEffort } from "./fs.js";
@@ -39,7 +40,7 @@ export { waitForHttpOk } from "./http.js";
 export { FETCH_TIMEOUT_MS, FetchTimeoutError, fetchWithTimeout } from "./fetch-with-timeout.js";
 export { wellKnownUserToolchainBins } from "./toolchain.js";
 export { execCommandViaLoginShell, execFileBuffered } from "./shell.js";
-export { AssetCacheError, assertSafePublicUrl, assetCacheKey, assetCacheRewriteUrl, createAssetCache, createValidatingLookup, isCacheableExternalUrl, } from "./asset-cache.js";
+export { AssetCacheError, assertSafePublicUrl, assetCacheKey, assetCacheRewriteUrl, createAssetCache, createAssetCacheDispatcher, createValidatingLookup, isCacheableExternalUrl, } from "./asset-cache.js";
 export { expandHomePrefix, resolveProjectRelativePath } from "./home-expansion.js";
 export { applySandboxRuntimeEnv, ensureSandboxRuntimeDirs, isSandboxImportedProjectRootAllowed, isSandboxModeEnabled, resolveSandboxRuntimeConfig, resolveSandboxRuntimeConfigFromEnv, sandboxAgentProfilesConfigPath, sandboxImportAllowedRoots, sandboxImportedProjectRootUnavailableReason, } from "./sandbox-env.js";
 export { resolveDaemonCliPath, resolveDaemonPluginPreviewsDir, resolveDaemonResourceDir, resolveDaemonResourceRoot, resolveDataDir, resolveProcessResourcesPath, } from "./resource-paths.js";

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

@@ -1,4 +1,7 @@
 export type { VendorCredentialSetRecord, VendorCredentialSetSummary, VendorCredentialSetRepoPort } from "./types.js";
-export { buildVendorCredentialAad } from "./aad.js";
-export { InMemoryVendorCredentialSetRepo } from "./repo.memory.js";
+export * from "./vault.types.js";
+export { buildVaultAad } from "./vault.aad.js";
+export { createVaultMetaParsers, isCopyableKind } from "./vault.meta.js";
+export { SecretsVaultService, type VaultServiceDeps, type VaultPutInput, type VaultCopyInput } from "./vault.service.js";
+export { InMemoryVaultRepo } from "./vault.repo.memory.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,3 +1,6 @@
-export { buildVendorCredentialAad } from "./aad.js";
-export { InMemoryVendorCredentialSetRepo } from "./repo.memory.js";
+export * from "./vault.types.js";
+export { buildVaultAad } from "./vault.aad.js";
+export { createVaultMetaParsers, isCopyableKind } from "./vault.meta.js";
+export { SecretsVaultService } from "./vault.service.js";
+export { InMemoryVaultRepo } from "./vault.repo.memory.js";
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,4 @@
+import type { VaultIdentity, VaultOptions } from "./vault.types.js";
+/** JSON tuple encoding prevents colons or separators in host identifiers aliasing another row. */
+export declare function buildVaultAad(input: VaultIdentity, _options?: VaultOptions): string;
+//# sourceMappingURL=vault.aad.d.ts.map

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

@@ -0,0 +1,8 @@
+import { formatAad } from "../aad.js";
+/** JSON tuple encoding prevents colons or separators in host identifiers aliasing another row. */
+export function buildVaultAad(input, _options = {}) {
+    return formatAad({ kind: "secrets-vault", version: "v1", parts: [JSON.stringify([
+                input.workspaceId, input.id, input.kind, input.ownerKey, input.principalId, input.binding,
+            ])] });
+}
+//# sourceMappingURL=vault.aad.js.map

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

@@ -0,0 +1,10 @@
+import { type VaultKind, type VaultMetaParsers, type VaultOptions } from "./vault.types.js";
+/** Copy eligibility lives with the kind contracts; MCP rows require their server configuration. */
+export declare const isCopyableKind: Readonly<Record<VaultKind, boolean>>;
+/** Minimal structural parsers. Hosts inject catalog, URL/origin and safe-metadata policy here;
+ * secrets stay in payload JSON. Overrides own the complete shape, including merged patches.
+ */
+export declare function createVaultMetaParsers(_required: VaultOptions, { parsers }?: {
+    parsers?: Partial<VaultMetaParsers>;
+}): VaultMetaParsers;
+//# sourceMappingURL=vault.meta.d.ts.map

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

@@ -0,0 +1,52 @@
+import { VAULT_KINDS, VaultError } from "./vault.types.js";
+/** Copy eligibility lives with the kind contracts; MCP rows require their server configuration. */
+export const isCopyableKind = Object.freeze({
+    "site-assistant": true, "personal-execution": false, "media-provider": true, custom: true,
+    "publish-peer": true, "database-destination": true, vendor: true, "source-control": true,
+    "mcp-env": false, "mcp-auth": false,
+});
+const FIELDS = {
+    "site-assistant": { baseUrl: "string", model: "string" },
+    "personal-execution": { protocol: "string", baseUrl: "string", model: "string", maxTokens: "number" },
+    "media-provider": { baseUrl: "string", model: "string" },
+    custom: { category: "string", baseUrl: "string", additionalHosts: "strings", username: "string" },
+    "publish-peer": { baseUrl: "string", remoteWorkspaceId: "string" },
+    "database-destination": { description: "object", lastRun: "object" },
+    vendor: { accountLabel: "string" }, "source-control": { accountLabel: "string" },
+    "mcp-env": {}, "mcp-auth": {},
+};
+function isObject(value) {
+    return value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
+}
+function isJson(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isJson);
+    return isObject(value) && Object.keys(value).every(key => !["__proto__", "constructor", "prototype"].includes(key) && isJson(value[key]));
+}
+/** Minimal structural parsers. Hosts inject catalog, URL/origin and safe-metadata policy here;
+ * secrets stay in payload JSON. Overrides own the complete shape, including merged patches.
+ */
+export function createVaultMetaParsers(_required, { parsers = {} } = {}) {
+    return Object.fromEntries(VAULT_KINDS.map(kind => [kind, ({ meta }) => {
+            if (!isObject(meta) || !isJson(meta) || Object.keys(meta).some(key => !/^[A-Za-z0-9_]+$/.test(key)))
+                throw new VaultError({ code: "invalid-meta" });
+            if (parsers[kind]) {
+                const parsed = parsers[kind]({ meta: structuredClone(meta) });
+                if (!isObject(parsed) || !isJson(parsed) || Object.keys(parsed).some(key => !/^[A-Za-z0-9_]+$/.test(key)))
+                    throw new VaultError({ code: "invalid-meta" });
+                return structuredClone(parsed);
+            }
+            for (const [key, value] of Object.entries(meta)) {
+                const field = Object.hasOwn(FIELDS[kind], key) ? FIELDS[kind][key] : undefined;
+                if (!field || (value !== null && !(field === "strings" ? Array.isArray(value) && value.every(v => typeof v === "string") :
+                    field === "object" ? isObject(value) : typeof value === field)))
+                    throw new VaultError({ code: "invalid-meta" });
+            }
+            return structuredClone(meta);
+        }]));
+}
+//# sourceMappingURL=vault.meta.js.map

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

@@ -0,0 +1,51 @@
+import { type VaultBatchOp, type VaultBatchResult, type VaultDefaultQuery, type VaultSingletonQuery, type VaultMeta, type VaultOptions, type VaultQuery, type VaultRecord, type VaultRepoPort } from "./vault.types.js";
+/** Single-turn mutations are atomic in JS; clones prevent callers bypassing CAS through aliases. */
+export declare class InMemoryVaultRepo implements VaultRepoPort {
+    private rows;
+    private singletons;
+    constructor(_required: VaultOptions, _options?: VaultOptions);
+    private key;
+    find(input: {
+        workspaceId: string;
+        id: string;
+    }, _options?: VaultOptions): Promise<VaultRecord | null>;
+    private singletonKey;
+    /** Index all four optional scope combinations; copy sets so batch staging never mutates live indexes. */
+    private indexSingleton;
+    /** Indexed singleton selection; clone only the selected row, ignoring provider/default. */
+    findOne(input: VaultSingletonQuery, _options?: VaultOptions): Promise<VaultRecord | null>;
+    /** Stage through the same mutation owner, then publish once. No await can expose partial rows
+     * or let a concurrent writer be lost between snapshot and swap. O(n + ops*n) fixture work.
+     */
+    applyBatch({ ops }: {
+        ops: readonly VaultBatchOp[];
+    }, _options?: VaultOptions): Promise<VaultBatchResult[]>;
+    /** 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>;
+    /** Synchronous mutation owner shared with batch staging; default moves never re-seal. */
+    private putRecord;
+    patchMeta(input: {
+        workspaceId: string;
+        id: string;
+        expectedRevision: number;
+        patch: VaultMeta;
+        updatedAt: string;
+    }, _options?: VaultOptions): Promise<VaultRecord>;
+    /** Clone merged metadata before mutating the staged/live map so failures leave it intact. */
+    private patchRecord;
+    delete(input: {
+        workspaceId: string;
+        id: string;
+        expectedRevision: number;
+    }, _options?: VaultOptions): Promise<boolean>;
+    /** Synchronous CAS delete shares promotion with provider moves and batch staging. */
+    private deleteRecord;
+    /** O(n) winner scan; promotion changes only default/revision, matching SQL. */
+    private promote;
+}
+//# sourceMappingURL=vault.repo.memory.d.ts.map