@jini-ai/platform 0.5.2 → 0.5.3

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,9 @@
 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, type VaultCommitPreparedInput } 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,8 @@
 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

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

@@ -0,0 +1,148 @@
+import { assertVaultReplacement, vaultGroupKey, VaultError } from "./vault.types.js";
+/** Single-turn mutations are atomic in JS; clones prevent callers bypassing CAS through aliases. */
+export class InMemoryVaultRepo {
+    rows = new Map();
+    singletons = new Map();
+    constructor(_required, _options = {}) { }
+    key(input) { return JSON.stringify([input.workspaceId, input.id]); }
+    async find(input, _options = {}) {
+        return structuredClone(this.rows.get(this.key(input)) ?? null);
+    }
+    singletonKey(input) {
+        return JSON.stringify([input.workspaceId, input.kind, input.ownerKey !== undefined, input.ownerKey ?? null,
+            input.principalId !== undefined, input.principalId ?? null]);
+    }
+    /** Index all four optional scope combinations; copy sets so batch staging never mutates live indexes. */
+    indexSingleton({ record, remove }, _options = {}) {
+        for (const ownerKey of [undefined, record.ownerKey])
+            for (const principalId of [undefined, record.principalId]) {
+                const scope = this.singletonKey({ workspaceId: record.workspaceId, kind: record.kind, ownerKey, principalId });
+                const ids = new Set(this.singletons.get(scope));
+                if (remove)
+                    ids.delete(this.key(record));
+                else
+                    ids.add(this.key(record));
+                if (ids.size)
+                    this.singletons.set(scope, ids);
+                else
+                    this.singletons.delete(scope);
+            }
+    }
+    /** Indexed singleton selection; clone only the selected row, ignoring provider/default. */
+    async findOne(input, _options = {}) {
+        const id = this.singletons.get(this.singletonKey(input))?.values().next().value;
+        return structuredClone(id === undefined ? null : this.rows.get(id));
+    }
+    /** 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.
+     */
+    async applyBatch({ ops }, _options = {}) {
+        const staged = new InMemoryVaultRepo({});
+        staged.rows = new Map(this.rows);
+        staged.singletons = new Map(this.singletons);
+        const results = ops.map(op => {
+            if ("put" in op)
+                return staged.putRecord(op.put);
+            if ("delete" in op)
+                return staged.deleteRecord(op.delete);
+            return staged.patchRecord(op.patchMeta);
+        });
+        this.rows = staged.rows;
+        this.singletons = staged.singletons;
+        return results;
+    }
+    /** O(n) memory scan, n stored rows; clones only the default, never its siblings. */
+    async findDefault(input, _options = {}) {
+        for (const row of this.rows.values()) {
+            if (row.isDefault && row.workspaceId === input.workspaceId && row.kind === input.kind && row.ownerKey === input.ownerKey &&
+                row.principalId === input.principalId && row.provider === input.provider)
+                return structuredClone(row);
+        }
+        return null;
+    }
+    async list(input, _options = {}) {
+        return structuredClone([...this.rows.values()].filter(row => row.workspaceId === input.workspaceId && row.kind === input.kind &&
+            row.ownerKey === input.ownerKey && row.principalId === input.principalId && (input.provider === undefined || row.provider === input.provider))
+            .sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    }
+    async put(input, _options = {}) {
+        return this.putRecord(input);
+    }
+    /** Synchronous mutation owner shared with batch staging; default moves never re-seal. */
+    putRecord(input, _options = {}) {
+        const { record } = input;
+        const key = this.key(record);
+        const existing = this.rows.get(key) ?? null;
+        assertVaultReplacement({ ...input, existing });
+        const groupKey = vaultGroupKey({ record });
+        let hasGroup = false;
+        for (const row of this.rows.values())
+            if (vaultGroupKey({ record: row }) === groupKey) {
+                hasGroup = true;
+                if (row.id !== record.id && row.label === record.label)
+                    throw new VaultError({ code: "conflict" });
+            }
+        const saved = structuredClone({ ...record, isDefault: record.isDefault || !hasGroup });
+        // Clear first, matching a SQL partial UNIQUE index; no transient duplicate default is required.
+        if (saved.isDefault)
+            for (const row of this.rows.values()) {
+                if (row.id !== saved.id && row.isDefault && vaultGroupKey({ record: row }) === groupKey) {
+                    this.rows.set(this.key(row), { ...row, isDefault: false, revision: row.revision + 1 });
+                }
+            }
+        this.rows.set(key, saved);
+        if (!existing)
+            this.indexSingleton({ record: saved, remove: false });
+        if (existing?.isDefault && vaultGroupKey({ record: existing }) !== groupKey)
+            this.promote({ record: existing });
+        return structuredClone(saved);
+    }
+    async patchMeta(input, _options = {}) {
+        return this.patchRecord(input);
+    }
+    /** Clone merged metadata before mutating the staged/live map so failures leave it intact. */
+    patchRecord(input, _options = {}) {
+        const key = this.key(input);
+        const existing = this.rows.get(key);
+        if (existing?.revision !== input.expectedRevision)
+            throw new VaultError({ code: "conflict" });
+        const saved = { ...existing, meta: structuredClone({ ...existing.meta, ...input.patch }), updatedAt: input.updatedAt, revision: existing.revision + 1 };
+        this.rows.set(key, saved);
+        return structuredClone(saved);
+    }
+    async delete(input, _options = {}) {
+        return this.deleteRecord(input);
+    }
+    /** Synchronous CAS delete shares promotion with provider moves and batch staging. */
+    deleteRecord(input, _options = {}) {
+        const key = this.key(input);
+        const existing = this.rows.get(key);
+        if (!existing)
+            return false;
+        if (existing.revision !== input.expectedRevision)
+            throw new VaultError({ code: "conflict" });
+        this.rows.delete(key);
+        this.indexSingleton({ record: existing, remove: true });
+        if (existing.isDefault)
+            this.promote({ record: existing });
+        return true;
+    }
+    /** O(n) winner scan; promotion changes only default/revision, matching SQL. */
+    promote({ record }, _options = {}) {
+        const groupKey = vaultGroupKey({ record });
+        let promoted;
+        // SQL BINARY/C compares UTF-8 bytes; JS's UTF-16 order differs for supplementary IDs.
+        for (const row of this.rows.values()) {
+            if (vaultGroupKey({ record: row }) === groupKey && (!promoted || row.updatedAt > promoted.updatedAt ||
+                (row.updatedAt === promoted.updatedAt && Buffer.compare(Buffer.from(row.id), Buffer.from(promoted.id)) > 0))) {
+                promoted = { id: row.id, updatedAt: row.updatedAt };
+            }
+        }
+        if (promoted) {
+            const promotedKey = this.key({ workspaceId: record.workspaceId, id: promoted.id });
+            const row = this.rows.get(promotedKey);
+            this.rows.set(promotedKey, { ...row, isDefault: true, revision: row.revision + 1 });
+        }
+    }
+}
+//# sourceMappingURL=vault.repo.memory.js.map

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

@@ -0,0 +1,130 @@
+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";
+export interface VaultServiceDeps {
+    repo: VaultRepoPort;
+    keyring: KeyringPort;
+    sealer: SecretSealerPort;
+    metaParsers: VaultMetaParsers;
+    /** Host policy must throw on denial. No permissive default is provided. */
+    authorize: (input: {
+        action: "put" | "get" | "list" | "rotate" | "delete";
+        context: VaultContext | VaultIdentity | VaultQuery;
+    }) => Promise<void>;
+    now: (input: VaultOptions) => string;
+    newId: (input: VaultOptions) => string;
+}
+export interface VaultPutInput extends VaultContext {
+    /** Omit for creation with an injected ID. Replacement requires id and expectedRevision. */
+    id?: string;
+    expectedRevision: number | null;
+    provider: string | null;
+    label: string;
+    meta: unknown;
+    /** null clears; omitted on replacement preserves the envelope/hint without opening or sealing.
+     * 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.
+     */
+    isDefault?: boolean;
+    /** A host-selected token, never a URI or serialized connection object. */
+    hintToken?: string;
+}
+/** Prepared records contain envelopes and stay private to the host, never a public read model.
+ * Expected revisions are mandatory for every ID; null means create-only. Deletes carry full
+ * expected ownership. Default side effects follow repository operation order (records, deletes).
+ */
+export interface VaultCommitPreparedInput {
+    records: readonly VaultRecord[];
+    deletes: readonly VaultIdentity[];
+    expectedRevisions: Readonly<Record<string, number | null>>;
+}
+export interface VaultCopyInput {
+    /** This service owns the source repository, authorization and keyring-backed sealer. */
+    source: SecretsVaultService;
+    sourceContext: VaultContext;
+    targetContext: VaultContext;
+    ids: readonly string[];
+    overwrite: boolean;
+    /** Optional selection-time guards; otherwise the revisions read by this operation are used. */
+    sourceRevisions?: Readonly<Record<string, number>>;
+    targetRevisions?: Readonly<Record<string, number | null>>;
+}
+/** Shared vault lifecycle. Policy/catalogs are injected; persistence and encryption are ports.
+ * Expected context is checked before opening. Normal reads have no legacy-AAD fallback.
+ * Metadata reads never need keys, and every merged patch is parsed before CAS persistence.
+ */
+export declare class SecretsVaultService {
+    private readonly deps;
+    constructor(deps: VaultServiceDeps, _options?: VaultOptions);
+    private authorize;
+    private parse;
+    private find;
+    private seal;
+    private open;
+    /** Create/replace configuration and a sealed JSON payload. Throws on policy, validation or CAS failure. */
+    put(input: VaultPutInput, _options?: VaultOptions): Promise<VaultSummary>;
+    /** Authorize, validate and seal before the host enters its transaction, without persisting.
+     * Replacements retain identity/createdAt; omitted payload preserves the existing envelope.
+     * Commit must CAS again because preparation does not reserve a revision or a default.
+     * @example const record = await vault.prepare(input); // pass to commitPrepared inside the host transaction
+     */
+    prepare(input: VaultPutInput, _options?: VaultOptions): Promise<VaultRecord>;
+    /** Reauthorize prepared rows, validate ownership/metadata, then commit through the batch owner.
+     * No plaintext is opened or sealed. Missing capability/revisions and duplicate identities fail
+     * before writes; stale CAS or a later operation failure rolls back the whole repository batch.
+     * @example await vault.commitPrepared({ records: [record], deletes: [], expectedRevisions: { [record.id]: null } });
+     */
+    commitPrepared(input: VaultCommitPreparedInput, _options?: VaultOptions): Promise<VaultSummary[]>;
+    /** Authorized runtime read; returns plaintext only to the caller that supplied exact ownership. */
+    get(input: VaultIdentity, _options?: VaultOptions): Promise<{
+        summary: VaultSummary;
+        payload: VaultMeta | null;
+    } | null>;
+    /** Singleton runtime read using one provider-independent lookup. Full expected ownership and
+     * binding are required before policy/decryption; repo callers may use a broader selection scope.
+     * @example await vault.findOne({ workspaceId, kind: "site-assistant", ownerKey: "assistant", principalId: null, binding: null });
+     */
+    findOne(input: VaultContext, _options?: VaultOptions): Promise<{
+        summary: VaultSummary;
+        payload: VaultMeta | null;
+    } | null>;
+    /** Authorized default read using one exact-group query; ownership is checked before opening.
+     * @throws On policy, context, metadata or authentication failure.
+     * @complexity One indexed row lookup, then O(payload size) decryption.
+     */
+    findDefault(input: VaultDefaultQuery & {
+        binding: string | null;
+    }, _options?: VaultOptions): Promise<{
+        summary: VaultSummary;
+        payload: VaultMeta | null;
+    } | null>;
+    /** Copy selected rows into this service without exposing plaintext or envelopes. Each ID is
+     * attempted once; failures are isolated and raw adapter/policy/crypto errors never escape.
+     * Source reads are plain SELECTs; this operation never upgrades or writes the source.
+     * @throws VaultError for invalid scopes. Per-row failures use fixed reason codes.
+     * @complexity O(n + payload bytes), n unique IDs; sequential bounded row reads and CAS writes.
+     */
+    copyToSite(input: VaultCopyInput, _options?: VaultOptions): Promise<VaultCopyResult[]>;
+    /** One transfer reuses both services' parsing/open/seal and the repository's default/CAS owner.
+     * @complexity Constant row queries plus O(payload size); no group read or source transaction.
+     */
+    private copyRow;
+    /** Human-managed scoped inventory. No envelope or plaintext is opened or returned. */
+    list(input: VaultQuery, _options?: VaultOptions): Promise<VaultSummary[]>;
+    /** Merge and validate complete metadata, then target only changed JSON keys with revision CAS. */
+    patchMeta(input: VaultIdentity & {
+        expectedRevision: number;
+        patch: VaultMeta;
+    }, _options?: VaultOptions): Promise<VaultSummary>;
+    /** Re-seal using the active key; concurrent replacement wins through CAS. Metadata-only rows persist. */
+    rotate(input: VaultIdentity & {
+        expectedRevision: number;
+    }, _options?: VaultOptions): Promise<VaultSummary>;
+    /** Idempotent for missing rows; existing rows require matching context and revision. */
+    delete(input: VaultIdentity & {
+        expectedRevision: number;
+    }, _options?: VaultOptions): Promise<boolean>;
+}
+//# sourceMappingURL=vault.service.d.ts.map