@jini-ai/platform 0.5.2 → 0.5.3

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

@@ -0,0 +1,310 @@
+import { credentialTokenHint } from "../credential-token.js";
+import { buildVaultAad } from "./vault.aad.js";
+import { isCopyableKind } from "./vault.meta.js";
+import { VAULT_KINDS, VaultError } from "./vault.types.js";
+function assertContext(context) {
+    if (typeof context.workspaceId !== "string" || !context.workspaceId || typeof context.ownerKey !== "string" || !context.ownerKey ||
+        !VAULT_KINDS.includes(context.kind) || (context.principalId !== null && typeof context.principalId !== "string") ||
+        ("binding" in context && context.binding !== null && typeof context.binding !== "string") ||
+        (context.kind === "personal-execution" && !context.principalId))
+        throw new VaultError({ code: "context" });
+}
+function summary(record) {
+    // Enumerate the read model: an adapter's extra runtime properties cannot become API fields.
+    return { workspaceId: record.workspaceId, id: record.id, kind: record.kind, ownerKey: record.ownerKey,
+        principalId: record.principalId, binding: record.binding, provider: record.provider, label: record.label,
+        isDefault: record.isDefault, revision: record.revision, tokenLength: record.tokenLength,
+        last4: record.tokenLength !== null && record.tokenLength >= 12 ? record.last4?.slice(-4) ?? null : null,
+        meta: record.meta, createdAt: record.createdAt, updatedAt: record.updatedAt, configured: record.sealed !== 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 class SecretsVaultService {
+    deps;
+    constructor(deps, _options = {}) {
+        this.deps = deps;
+    }
+    authorize(input) {
+        const context = input.context;
+        // Policy adapters receive only scope, never a put payload or a metadata patch through an
+        // extra-property alias. This also keeps ordinary authorization diagnostics secret-free.
+        return this.deps.authorize({ action: input.action, context: { workspaceId: context.workspaceId,
+                kind: context.kind, ownerKey: context.ownerKey, principalId: context.principalId,
+                ...("binding" in context ? { binding: context.binding } : {}),
+                ...("id" in context ? { id: context.id } : {}),
+                ...("provider" in context && context.provider !== undefined ? { provider: context.provider } : {}) } });
+    }
+    parse(record) {
+        assertContext(record);
+        return { ...record, meta: this.deps.metaParsers[record.kind]({ meta: record.meta }) };
+    }
+    async find(input) {
+        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);
+    }
+    async seal(input) {
+        if (input.payload === null)
+            return null;
+        // JSON round-trip makes the payload contract explicit; encryption never receives an object
+        // coerced to '[object Object]' or a connection URI masquerading as an entire payload.
+        if (typeof input.payload !== "object" || Array.isArray(input.payload))
+            throw new VaultError({ code: "invalid-record" });
+        const plaintext = JSON.stringify(input.payload);
+        return this.deps.sealer.seal({ plaintext, key: await this.deps.keyring.activeKey({}), aad: buildVaultAad(input.context) });
+    }
+    async open(record) {
+        if (!record.sealed)
+            return null;
+        const plaintext = await this.deps.sealer.open({ sealed: record.sealed }, { aad: buildVaultAad(record) });
+        let payload;
+        try {
+            payload = JSON.parse(plaintext);
+        }
+        catch {
+            throw new VaultError({ code: "invalid-record" });
+        }
+        if (payload === null || typeof payload !== "object" || Array.isArray(payload))
+            throw new VaultError({ code: "invalid-record" });
+        return payload;
+    }
+    /** Create/replace configuration and a sealed JSON payload. Throws on policy, validation or CAS failure. */
+    async put(input, _options = {}) {
+        const record = await this.prepare(input);
+        return summary(this.parse(await this.deps.repo.put({ record, expectedRevision: input.expectedRevision })));
+    }
+    /** 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
+     */
+    async prepare(input, _options = {}) {
+        assertContext(input);
+        await this.authorize({ action: "put", context: input });
+        if (input.expectedRevision !== null && !input.id)
+            throw new VaultError({ code: "conflict" });
+        const identity = { workspaceId: input.workspaceId, kind: input.kind, ownerKey: input.ownerKey,
+            principalId: input.principalId, binding: input.binding, id: input.id ?? this.deps.newId({}) };
+        const existing = await this.find(identity);
+        if (input.expectedRevision === null ? existing !== null : existing?.revision !== input.expectedRevision)
+            throw new VaultError({ code: "conflict" });
+        const meta = this.deps.metaParsers[input.kind]({ meta: input.meta });
+        if (input.payload === undefined && !existing)
+            throw new VaultError({ code: "invalid-record" });
+        const sealed = input.payload === undefined ? existing.sealed : await this.seal({ context: identity, payload: input.payload });
+        // Never expose any suffix of a database address, environment map or OAuth session.
+        const hint = sealed && input.hintToken !== undefined && !["database-destination", "mcp-env", "mcp-auth"].includes(input.kind)
+            ? credentialTokenHint({ token: input.hintToken }) : null;
+        const now = this.deps.now({});
+        const record = { ...identity, provider: input.provider, label: input.label, meta, sealed,
+            isDefault: input.isDefault ?? (existing !== null && existing.provider === input.provider && existing.isDefault),
+            revision: (input.expectedRevision ?? 0) + 1,
+            last4: input.payload === undefined ? existing.last4 : hint?.last4 ?? null,
+            tokenLength: input.payload === undefined ? existing.tokenLength : hint?.length ?? null,
+            createdAt: existing?.createdAt ?? now, updatedAt: now };
+        return record;
+    }
+    /** 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 } });
+     */
+    async commitPrepared(input, _options = {}) {
+        if (!this.deps.repo.applyBatch)
+            throw new VaultError({ code: "invalid-record" });
+        const { records, deletes, expectedRevisions } = structuredClone(input);
+        const identities = new Set();
+        const ops = [];
+        const entries = [...records.map(record => ({ put: record })), ...deletes.map(record => ({ delete: record }))];
+        for (const entry of entries) {
+            const record = "put" in entry ? entry.put : entry.delete;
+            assertContext(record);
+            const key = JSON.stringify([record.workspaceId, record.id]);
+            if (identities.has(key) || !Object.hasOwn(expectedRevisions, record.id))
+                throw new VaultError({ code: "invalid-record" });
+            identities.add(key);
+            const expectedRevision = expectedRevisions[record.id];
+            const putting = "put" in entry;
+            await this.authorize({ action: putting ? "put" : "delete", context: record });
+            const existing = await this.find(record);
+            if (expectedRevision === null ? existing !== null : existing?.revision !== expectedRevision)
+                throw new VaultError({ code: "conflict" });
+            if ("put" in entry)
+                ops.push({ put: { record: this.parse(entry.put), expectedRevision } });
+            else {
+                if (expectedRevision === null)
+                    throw new VaultError({ code: "invalid-record" });
+                ops.push({ delete: { workspaceId: record.workspaceId, id: record.id, expectedRevision } });
+            }
+        }
+        const results = await this.deps.repo.applyBatch({ ops });
+        return results.filter((result) => typeof result !== "boolean").map(summary);
+    }
+    /** Authorized runtime read; returns plaintext only to the caller that supplied exact ownership. */
+    async get(input, _options = {}) {
+        assertContext(input);
+        await this.authorize({ action: "get", context: input });
+        const record = await this.find(input);
+        return record ? { summary: summary(record), payload: await this.open(record) } : 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 });
+     */
+    async findOne(input, _options = {}) {
+        assertContext(input);
+        await this.authorize({ action: "get", context: input });
+        if (!this.deps.repo.findOne)
+            throw new VaultError({ code: "invalid-record" });
+        const record = await this.deps.repo.findOne(input);
+        if (!record)
+            return null;
+        if (buildVaultAad({ ...input, id: record.id }) !== buildVaultAad(record))
+            throw new VaultError({ code: "context" });
+        const parsed = this.parse(record);
+        return { summary: summary(parsed), payload: await this.open(parsed) };
+    }
+    /** 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.
+     */
+    async findDefault(input, _options = {}) {
+        assertContext(input);
+        await this.authorize({ action: "get", context: input });
+        // Old injected ports retain their existing operations; default reads require this capability.
+        if (!this.deps.repo.findDefault)
+            throw new VaultError({ code: "invalid-record" });
+        const record = await this.deps.repo.findDefault(input);
+        if (!record)
+            return null;
+        if (!record.isDefault || record.provider !== input.provider || buildVaultAad({ ...input, id: record.id }) !== buildVaultAad(record)) {
+            throw new VaultError({ code: "context" });
+        }
+        const parsed = this.parse(record);
+        return { summary: summary(parsed), payload: await this.open(parsed) };
+    }
+    /** 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.
+     */
+    async copyToSite(input, _options = {}) {
+        assertContext(input.sourceContext);
+        assertContext(input.targetContext);
+        const results = [];
+        for (const id of new Set(input.ids))
+            results.push(await this.copyRow({ ...input, id }));
+        return results;
+    }
+    /** 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.
+     */
+    async copyRow(input, _options = {}) {
+        const { source, sourceContext, targetContext, id } = input;
+        const result = { kind: sourceContext.kind, id };
+        if (!isCopyableKind[sourceContext.kind])
+            return { ...result, status: "skipped",
+                reasonCode: sourceContext.kind === "mcp-env" ? "requires-mcp-configuration" : "kind-not-copyable" };
+        try {
+            // Copy changes the site/key, never the credential's owning feature or endpoint. Principal
+            // identities are local to each installation and cannot be carried to the target.
+            if (sourceContext.kind !== targetContext.kind || sourceContext.ownerKey !== targetContext.ownerKey ||
+                sourceContext.binding !== targetContext.binding || sourceContext.principalId !== null || targetContext.principalId !== null ||
+                (source.deps.repo === this.deps.repo && sourceContext.workspaceId === targetContext.workspaceId)) {
+                throw new VaultError({ code: "context" });
+            }
+            const sourceIdentity = { ...sourceContext, id };
+            const targetIdentity = { ...targetContext, id };
+            await source.authorize({ action: "get", context: sourceIdentity });
+            await this.authorize({ action: "put", context: targetIdentity });
+            const raw = await source.deps.repo.find(sourceIdentity);
+            if (!raw)
+                return { ...result, status: "failed", reasonCode: "source-missing" };
+            if (buildVaultAad(sourceIdentity) !== buildVaultAad(raw))
+                throw new VaultError({ code: "context" });
+            // Check before parsing: normal parsers deliberately reject legacy-AAD metadata.
+            if (Object.hasOwn(raw.meta, "legacyAad"))
+                return { ...result, status: "failed", reasonCode: "source-needs-upgrade" };
+            if (input.sourceRevisions && Object.hasOwn(input.sourceRevisions, id) && input.sourceRevisions[id] !== raw.revision)
+                throw new VaultError({ code: "conflict" });
+            const record = source.parse(raw);
+            const existing = await this.find(targetIdentity);
+            if (existing && !input.overwrite)
+                return { ...result, status: "skipped", reasonCode: "target-exists" };
+            if (existing && existing.provider !== record.provider)
+                throw new VaultError({ code: "context" });
+            const expectedRevision = existing?.revision ?? null;
+            if (input.targetRevisions && Object.hasOwn(input.targetRevisions, id) && input.targetRevisions[id] !== expectedRevision)
+                throw new VaultError({ code: "conflict" });
+            const now = this.deps.now({});
+            const candidate = this.parse({ ...record, ...targetIdentity, isDefault: existing?.isDefault ?? false,
+                revision: (expectedRevision ?? 0) + 1, createdAt: existing?.createdAt ?? now, 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.
+            candidate.last4 = record.kind === "database-destination" ? null : summary(record).last4;
+            candidate.tokenLength = record.kind === "database-destination" ? null : record.tokenLength;
+            const saved = await this.deps.repo.put({ record: candidate, expectedRevision });
+            const last4 = summary(saved).last4;
+            return { ...result, status: "copied", ...(last4 ? { last4 } : {}) };
+        }
+        catch (error) {
+            return { ...result, status: "failed", reasonCode: error instanceof VaultError ? error.code : "copy-failed" };
+        }
+    }
+    /** Human-managed scoped inventory. No envelope or plaintext is opened or returned. */
+    async list(input, _options = {}) {
+        assertContext(input);
+        await this.authorize({ action: "list", context: input });
+        return (await this.deps.repo.list(input)).map(record => {
+            if (record.workspaceId !== input.workspaceId || record.kind !== input.kind || record.ownerKey !== input.ownerKey ||
+                record.principalId !== input.principalId || (input.provider !== undefined && record.provider !== input.provider))
+                throw new VaultError({ code: "context" });
+            return summary(this.parse(record));
+        });
+    }
+    /** Merge and validate complete metadata, then target only changed JSON keys with revision CAS. */
+    async patchMeta(input, _options = {}) {
+        assertContext(input);
+        await this.authorize({ action: "put", context: input });
+        const existing = await this.find(input);
+        if (existing?.revision !== input.expectedRevision)
+            throw new VaultError({ code: "conflict" });
+        const meta = this.deps.metaParsers[existing.kind]({ meta: { ...existing.meta, ...input.patch } });
+        // jsonSet can add/replace a key but cannot remove one. Reject parser omissions instead of
+        // silently persisting an unvalidated old field. Normalized values and defaults can be patched.
+        if (Object.keys({ ...existing.meta, ...input.patch }).some(key => !Object.hasOwn(meta, key)))
+            throw new VaultError({ code: "invalid-meta" });
+        const patch = Object.fromEntries(Object.entries(meta).filter(([key, value]) => JSON.stringify(value) !== JSON.stringify(existing.meta[key])));
+        return summary(this.parse(await this.deps.repo.patchMeta({ workspaceId: input.workspaceId, id: input.id,
+            expectedRevision: input.expectedRevision, patch, updatedAt: this.deps.now({}) })));
+    }
+    /** Re-seal using the active key; concurrent replacement wins through CAS. Metadata-only rows persist. */
+    async rotate(input, _options = {}) {
+        assertContext(input);
+        await this.authorize({ action: "rotate", context: input });
+        const existing = await this.find(input);
+        if (existing?.revision !== input.expectedRevision)
+            throw new VaultError({ code: "conflict" });
+        const sealed = await this.seal({ context: input, payload: await this.open(existing) });
+        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. */
+    async delete(input, _options = {}) {
+        assertContext(input);
+        await this.authorize({ action: "delete", context: input });
+        const existing = await this.find(input);
+        if (!existing)
+            return false;
+        if (existing.revision !== input.expectedRevision)
+            throw new VaultError({ code: "conflict" });
+        return this.deps.repo.delete({ workspaceId: input.workspaceId, id: input.id, expectedRevision: input.expectedRevision });
+    }
+}
+//# sourceMappingURL=vault.service.js.map

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

@@ -0,0 +1,150 @@
+import type { SealedSecret } from "../types.js";
+export declare const VAULT_KINDS: readonly ["site-assistant", "personal-execution", "media-provider", "custom", "publish-peer", "database-destination", "vendor", "source-control", "mcp-env", "mcp-auth"];
+export type VaultKind = typeof VAULT_KINDS[number];
+export type VaultJson = null | boolean | number | string | VaultJson[] | {
+    [key: string]: VaultJson;
+};
+export type VaultMeta = {
+    [key: string]: VaultJson;
+};
+export type VaultOptions = Record<string, never>;
+/** Expected ownership is supplied by the caller, never reconstructed from an untrusted row. */
+export interface VaultContext {
+    workspaceId: string;
+    kind: VaultKind;
+    ownerKey: string;
+    principalId: string | null;
+    /** Host-canonicalized endpoint/resource binding; null for credentials without such a binding. */
+    binding: string | null;
+}
+export interface VaultIdentity extends VaultContext {
+    id: string;
+}
+export interface VaultRecord extends VaultIdentity {
+    provider: string | null;
+    label: string;
+    isDefault: boolean;
+    revision: number;
+    sealed: SealedSecret | null;
+    last4: string | null;
+    tokenLength: number | null;
+    meta: VaultMeta;
+    createdAt: string;
+    updatedAt: string;
+}
+export type VaultSummary = Omit<VaultRecord, "sealed"> & {
+    configured: boolean;
+};
+export interface VaultQuery {
+    workspaceId: string;
+    kind: VaultKind;
+    ownerKey: string;
+    principalId: string | null;
+    provider?: string | null;
+}
+/** A default belongs to one exact group; omitted provider never means all providers. */
+export interface VaultDefaultQuery extends VaultQuery {
+    provider: string | null;
+}
+/** Singleton lookup ignores provider/default; omitted owner/principal leave that dimension unfiltered.
+ * Hosts enforce singleton cardinality for their kind/scope. No binding is inferred by the service.
+ */
+export interface VaultSingletonQuery {
+    workspaceId: string;
+    kind: VaultKind;
+    ownerKey?: string | undefined;
+    principalId?: string | null | undefined;
+}
+/** Ordered CAS operations; default side effects affect later operations' revisions. */
+export type VaultBatchOp = {
+    put: {
+        record: VaultRecord;
+        expectedRevision: number | null;
+    };
+} | {
+    delete: {
+        workspaceId: string;
+        id: string;
+        expectedRevision: number;
+    };
+} | {
+    patchMeta: {
+        workspaceId: string;
+        id: string;
+        expectedRevision: number;
+        patch: VaultMeta;
+        updatedAt: string;
+    };
+};
+export type VaultBatchResult = VaultRecord | boolean;
+export interface VaultCopyResult {
+    kind: VaultKind;
+    id: string;
+    status: "copied" | "skipped" | "failed";
+    last4?: string;
+    reasonCode?: VaultError["code"] | "source-needs-upgrade" | "source-missing" | "target-exists" | "kind-not-copyable" | "requires-mcp-configuration" | "copy-failed";
+}
+export type VaultMetaParser = (input: {
+    meta: unknown;
+}, options?: VaultOptions) => VaultMeta;
+export type VaultMetaParsers = Readonly<Record<VaultKind, VaultMetaParser>>;
+/** Safe error codes never contain submitted values or encrypted material. */
+export declare class VaultError extends Error {
+    readonly code: "conflict" | "context" | "invalid-meta" | "invalid-record";
+    constructor({ code }: {
+        code: VaultError["code"];
+    }, _options?: VaultOptions);
+}
+/** CAS is mandatory: null creates only; a number replaces/deletes only that revision.
+ * Defaults group by workspace/kind/owner/principal/provider. Every default change increments
+ * revision; promotion uses updatedAt descending, then id descending (binary UTF-8 order).
+ * All writes must join a host transaction when the adapter supports transaction composition.
+ */
+export interface VaultRepoPort {
+    find(input: {
+        workspaceId: string;
+        id: string;
+    }, options?: VaultOptions): Promise<VaultRecord | null>;
+    /** Indexed exact-group lookup; returns at most one row without listing its siblings.
+     * Optional for compatibility with pre-C1 ports; both built-in adapters implement it.
+     */
+    findDefault?(input: VaultDefaultQuery, options?: VaultOptions): Promise<VaultRecord | null>;
+    /** Optional additions keep older injected ports source-compatible; built-in adapters implement both. */
+    findOne?(input: VaultSingletonQuery, options?: VaultOptions): Promise<VaultRecord | null>;
+    /** All operations commit together or throw with no published changes.
+     * SQL joins the host transaction: callers must propagate failures to roll that transaction back.
+     * @example await repo.applyBatch!({ ops: [{ put: { record, expectedRevision: null } }] });
+     */
+    applyBatch?(input: {
+        ops: readonly VaultBatchOp[];
+    }, options?: VaultOptions): Promise<VaultBatchResult[]>;
+    list(input: VaultQuery, options?: VaultOptions): Promise<VaultRecord[]>;
+    put(input: {
+        record: VaultRecord;
+        expectedRevision: number | null;
+    }, options?: VaultOptions): Promise<VaultRecord>;
+    /** Service-validated patch: top-level keys are plain JSON-path identifiers. */
+    patchMeta(input: {
+        workspaceId: string;
+        id: string;
+        expectedRevision: number;
+        patch: VaultMeta;
+        updatedAt: string;
+    }, options?: VaultOptions): Promise<VaultRecord>;
+    delete(input: {
+        workspaceId: string;
+        id: string;
+        expectedRevision: number;
+    }, options?: VaultOptions): Promise<boolean>;
+}
+/** Unambiguous scope encoding keeps adapter default/identity checks on the same contract. */
+export declare function vaultGroupKey({ record }: {
+    record: VaultRecord;
+}, _options?: VaultOptions): string;
+/** Adapters guard CAS and immutable identity even for callers below the service. */
+export declare function assertVaultReplacement({ record, existing, expectedRevision }: {
+    record: VaultRecord;
+    existing: VaultRecord | null;
+    expectedRevision: number | null;
+}, _options?: VaultOptions): void;
+//# sourceMappingURL=vault.types.d.ts.map

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

@@ -0,0 +1,28 @@
+export const VAULT_KINDS = ["site-assistant", "personal-execution", "media-provider", "custom", "publish-peer",
+    "database-destination", "vendor", "source-control", "mcp-env", "mcp-auth"];
+/** Safe error codes never contain submitted values or encrypted material. */
+export class VaultError extends Error {
+    code;
+    constructor({ code }, _options = {}) {
+        super(`Secrets vault: ${code}`);
+        this.code = code;
+        this.name = "VaultError";
+    }
+}
+/** Unambiguous scope encoding keeps adapter default/identity checks on the same contract. */
+export function vaultGroupKey({ record }, _options = {}) {
+    return JSON.stringify([record.workspaceId, record.kind, record.ownerKey, record.principalId, record.provider]);
+}
+/** Adapters guard CAS and immutable identity even for callers below the service. */
+export function assertVaultReplacement({ record, existing, expectedRevision }, _options = {}) {
+    if (expectedRevision === null ? existing !== null : existing?.revision !== expectedRevision)
+        throw new VaultError({ code: "conflict" });
+    if (!Number.isSafeInteger(record.revision) || record.revision !== (expectedRevision ?? 0) + 1)
+        throw new VaultError({ code: "invalid-record" });
+    // Provider groups defaults, but is not authenticated identity (see buildVaultAad).
+    if (existing && (record.workspaceId !== existing.workspaceId || record.kind !== existing.kind ||
+        record.ownerKey !== existing.ownerKey || record.principalId !== existing.principalId ||
+        record.id !== existing.id || record.binding !== existing.binding || record.createdAt !== existing.createdAt))
+        throw new VaultError({ code: "context" });
+}
+//# sourceMappingURL=vault.types.js.map

package/dist/web/html-document.d.ts

@@ -0,0 +1,70 @@
+import { type DefaultTreeAdapterMap } from "parse5";
+type Element = DefaultTreeAdapterMap["element"];
+export interface PageLink {
+    href: string;
+    text: string;
+    internal: boolean;
+}
+export interface PageImage {
+    src: string;
+    alt: string;
+}
+export interface HtmlDocumentFacts {
+    title?: string;
+    description?: string;
+    lang?: string;
+    links: PageLink[];
+    linksTruncated: boolean;
+    images: PageImage[];
+    imagesTruncated: boolean;
+    stylesheets: string[];
+    meta: Record<string, string>;
+}
+export declare const MAX_LINKS = 500;
+export declare const MAX_IMAGES = 300;
+export declare const LINK_PROTOCOLS: ReadonlySet<string>;
+export declare const ASSET_PROTOCOLS: ReadonlySet<string>;
+export declare function attr({ element, name }: {
+    element: Element;
+    name: string;
+}, _optional?: Record<string, never>): string | undefined;
+/** Resolves against `base`; drops fragment-only, unparseable and other-protocol values, and fragments. */
+export declare function absolute({ raw, base, protocols }: {
+    raw: string | undefined;
+    base: string;
+    protocols: ReadonlySet<string>;
+}, _optional?: Record<string, never>): string | undefined;
+/** First usable image URL: lazy loaders park the real one in `data-src` behind a `data:` placeholder. */
+export declare function imageSource({ img }: {
+    img: Element;
+}, _optional?: Record<string, never>): string | undefined;
+/**
+ * Extracts page facts. Relative URLs resolve against `<base href>` (itself resolved against the page
+ * URL) so links match what a browser would follow.
+ * @param required.html - Decoded page source; untrusted.
+ * @param required.pageUrl - The final URL the HTML was served from (after redirects).
+ * @returns Facts with every URL absolute; links deduped (fragment-free) and capped at {@link MAX_LINKS},
+ *   images at {@link MAX_IMAGES}; `internal` ignores a leading `www.`.
+ * @complexity O(nodes) plus O(anchor subtree) per anchor for its text.
+ */
+export declare function readHtmlDocument({ html, pageUrl }: {
+    html: string;
+    pageUrl: string;
+}, _optional?: Record<string, never>): HtmlDocumentFacts;
+/**
+ * Visible text with one line per block element; scripts, styles, `<head>`, SVG and embeds omitted.
+ * @complexity O(nodes).
+ */
+export declare function htmlToText({ html }: {
+    html: string;
+}, _optional?: Record<string, never>): string;
+/**
+ * The page HTML with `<script>`, `<noscript>`, `<template>`, comments, `on*` handler attributes and
+ * `javascript:` attribute values removed (styles and classes kept: theming needs them). Re-serialized by parse5, so it is well-formed rather than byte-identical.
+ * @complexity O(nodes).
+ */
+export declare function stripActiveHtml({ html }: {
+    html: string;
+}, _optional?: Record<string, never>): string;
+export {};
+//# sourceMappingURL=html-document.d.ts.map