@fungi.computer/truffle 0.0.0-stage → 0.2.0

package/dist/private-mcp-form-session.d.ts

@@ -0,0 +1,172 @@
+import type { Approvals, PendingApproval } from "@fungi.computer/approvals";
+import type { ShiitakeSession } from "@fungi.computer/shiitake";
+import { type LocalUiAttachment } from "./private-local-ui-attachment.js";
+/** Host-owned references to canonical approvals; no suspended tool or second ledger. */
+export declare function createMcpFormSession(): {
+    extension: import("@fungi.computer/shiitake/extensions").DefinedExtensionV0<{
+        answer: {
+            scope: "session";
+            input: import("effect/Schema").Struct<{
+                readonly id: import("effect/Schema").String;
+                readonly decision: import("effect/Schema").Literals<readonly ["approve", "deny"]>;
+                readonly expectedRevision: import("effect/Schema").Int;
+            }>;
+            output: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"answered">;
+                readonly view: import("effect/Schema").Struct<{
+                    readonly record: import("effect/Schema").Struct<{
+                        readonly recordId: import("effect/Schema").String;
+                        readonly requester: import("effect/Schema").Struct<{
+                            readonly principalId: import("effect/Schema").String;
+                            readonly agentId: import("effect/Schema").NullOr<import("effect/Schema").String>;
+                            readonly sessionId: import("effect/Schema").NullOr<import("effect/Schema").String>;
+                            readonly displayName: import("effect/Schema").String;
+                        }>;
+                        readonly module: import("effect/Schema").String;
+                        readonly operation: import("effect/Schema").String;
+                        readonly access: import("effect/Schema").Literals<readonly ["write", "external"]>;
+                        readonly description: import("effect/Schema").Struct<{
+                            readonly title: import("effect/Schema").String;
+                            readonly inputBytes: import("effect/Schema").Int;
+                            readonly inputSha256: import("effect/Schema").String;
+                        }>;
+                        readonly evidence: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                            readonly kind: import("effect/Schema").Literal<"artifact">;
+                            readonly ref: import("effect/Schema").String;
+                            readonly mediaType: import("effect/Schema").Literal<"image/png">;
+                            readonly bytes: import("effect/Schema").Int;
+                        }>>>;
+                        readonly authorityFence: import("effect/Schema").String;
+                        readonly reversibility: import("effect/Schema").Literals<readonly ["reversible", "irreversible-external"]>;
+                        readonly state: import("effect/Schema").Literals<readonly ["requested", "pending", "approved", "claimed", "applied", "denied", "expired", "outcome_unknown"]>;
+                        readonly by: import("effect/Schema").NullOr<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                            readonly kind: import("effect/Schema").Literal<"human">;
+                            readonly memberId: import("effect/Schema").String;
+                        }>, import("effect/Schema").Struct<{
+                            readonly kind: import("effect/Schema").Literal<"policy">;
+                        }>]>>;
+                        readonly reason: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>>;
+                        readonly requestedAt: import("effect/Schema").Int;
+                        readonly expiresAt: import("effect/Schema").Int;
+                        readonly updatedAt: import("effect/Schema").Int;
+                        readonly revision: import("effect/Schema").Int;
+                    }>;
+                    readonly canAnswer: import("effect/Schema").Boolean;
+                    readonly canSetAutoApprove: import("effect/Schema").Boolean;
+                }>;
+            }>, import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"refused">;
+                readonly reason: import("effect/Schema").Literals<readonly ["not-found", "not-eligible", "already-answered", "stale-revision", "expired", "declined", "fenced", "not-granted", "read-only", "pending", "in-flight", "outcome-unknown", "identity-conflict"]>;
+            }>, import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"submitted">;
+            }>, import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"refused">;
+                readonly reason: import("effect/Schema").Literals<readonly ["not-attached", "not-pending"]>;
+            }>]>;
+        };
+    }, {
+        readonly pending: readonly {
+            readonly id: string;
+            readonly approval: {
+                readonly record: {
+                    readonly operation: string;
+                    readonly state: "pending" | "expired" | "requested" | "approved" | "claimed" | "applied" | "denied" | "outcome_unknown";
+                    readonly access: "write" | "external";
+                    readonly reason: "pending" | "not-found" | "not-eligible" | "already-answered" | "stale-revision" | "expired" | "declined" | "fenced" | "not-granted" | "read-only" | "in-flight" | "outcome-unknown" | "identity-conflict" | null;
+                    readonly recordId: string;
+                    readonly requester: {
+                        readonly principalId: string;
+                        readonly agentId: string | null;
+                        readonly sessionId: string | null;
+                        readonly displayName: string;
+                    };
+                    readonly module: string;
+                    readonly description: {
+                        readonly title: string;
+                        readonly inputBytes: number;
+                        readonly inputSha256: string;
+                    };
+                    readonly authorityFence: string;
+                    readonly reversibility: "reversible" | "irreversible-external";
+                    readonly by: {
+                        readonly kind: "human";
+                        readonly memberId: string;
+                    } | {
+                        readonly kind: "policy";
+                    } | null;
+                    readonly requestedAt: number;
+                    readonly expiresAt: number;
+                    readonly updatedAt: number;
+                    readonly revision: number;
+                    readonly evidence?: readonly {
+                        readonly kind: "artifact";
+                        readonly ref: string;
+                        readonly mediaType: "image/png";
+                        readonly bytes: number;
+                    }[];
+                };
+                readonly canAnswer: boolean;
+                readonly canSetAutoApprove: boolean;
+            };
+        }[];
+    }, {
+        readonly pending: readonly {
+            readonly id: string;
+            readonly approval: {
+                readonly record: {
+                    readonly operation: string;
+                    readonly state: "pending" | "expired" | "requested" | "approved" | "claimed" | "applied" | "denied" | "outcome_unknown";
+                    readonly access: "write" | "external";
+                    readonly reason: "pending" | "not-found" | "not-eligible" | "already-answered" | "stale-revision" | "expired" | "declined" | "fenced" | "not-granted" | "read-only" | "in-flight" | "outcome-unknown" | "identity-conflict" | null;
+                    readonly recordId: string;
+                    readonly requester: {
+                        readonly principalId: string;
+                        readonly agentId: string | null;
+                        readonly sessionId: string | null;
+                        readonly displayName: string;
+                    };
+                    readonly module: string;
+                    readonly description: {
+                        readonly title: string;
+                        readonly inputBytes: number;
+                        readonly inputSha256: string;
+                    };
+                    readonly authorityFence: string;
+                    readonly reversibility: "reversible" | "irreversible-external";
+                    readonly by: {
+                        readonly kind: "human";
+                        readonly memberId: string;
+                    } | {
+                        readonly kind: "policy";
+                    } | null;
+                    readonly requestedAt: number;
+                    readonly expiresAt: number;
+                    readonly updatedAt: number;
+                    readonly revision: number;
+                    readonly evidence?: readonly {
+                        readonly kind: "artifact";
+                        readonly ref: string;
+                        readonly mediaType: "image/png";
+                        readonly bytes: number;
+                    }[];
+                };
+                readonly canAnswer: boolean;
+                readonly canSetAutoApprove: boolean;
+            };
+        }[];
+    }>;
+    presentApproval: (sessionId: string, submitted: PendingApproval, approvals: Approvals) => Promise<{
+        readonly kind: "refused";
+        readonly reason: "not-pending";
+        readonly id?: never;
+    } | {
+        readonly kind: "presented";
+        readonly id: string;
+        reason?: never;
+    } | {
+        readonly kind: "refused";
+        readonly reason: "capacity";
+        readonly id?: never;
+    }>;
+    bindSession: (sessionId: string, session: ShiitakeSession, attachment: LocalUiAttachment | undefined) => ShiitakeSession;
+};

package/dist/private-mcp-form-session.js

@@ -0,0 +1,148 @@
+import { correlationKey } from "@fungi.computer/cairn";
+import { defineExtension } from "@fungi.computer/shiitake/extensions";
+import * as Effect from "effect/Effect";
+import { mcpFormApprovalContract, } from "./private-mcp-form-contract.js";
+import { consumeLocalUiCommand, runLocalUiCommand, startLocalUiWatch, } from "./private-local-ui-attachment.js";
+const maximumPendingForms = 100;
+/** Host-owned references to canonical approvals; no suspended tool or second ledger. */
+export function createMcpFormSession() {
+    const pending = new Map();
+    let publish;
+    const extension = defineExtension({
+        id: mcpFormApprovalContract.id,
+        version: "1.0.0",
+    }).define({
+        commands: {
+            specs: mcpFormApprovalContract.commands,
+            handlers: (context) => ({
+                answer: ({ sessionId, input }) => Effect.gen(function* () {
+                    const onComplete = consumeLocalUiCommand(sessionId);
+                    if (onComplete === undefined) {
+                        const result = {
+                            kind: "refused",
+                            reason: "not-attached",
+                        };
+                        return result;
+                    }
+                    const entry = pending.get(input.id);
+                    if (entry?.sessionId !== sessionId) {
+                        const result = {
+                            kind: "refused",
+                            reason: "not-pending",
+                        };
+                        return result;
+                    }
+                    if (entry.answering) {
+                        const result = {
+                            kind: "refused",
+                            reason: "in-flight",
+                        };
+                        return result;
+                    }
+                    entry.answering = true;
+                    onComplete(async (committed) => {
+                        try {
+                            if (!committed)
+                                return { kind: "refused", reason: "not-attached" };
+                            // Session commit and live UI recheck precede the canonical
+                            // decision. Its bound host, never MCP accept, owns apply.
+                            return await entry.approvals.answer({
+                                recordId: entry.approval.record.recordId,
+                                decision: input.decision,
+                                expectedRevision: input.expectedRevision,
+                            });
+                        }
+                        finally {
+                            entry.answering = false;
+                            const view = await entry.approvals.get({
+                                recordId: entry.approval.record.recordId,
+                            });
+                            if (view?.record.state !== "pending")
+                                pending.delete(input.id);
+                            else
+                                entry.approval = view;
+                            await publish?.(sessionId);
+                        }
+                    });
+                    yield* context.observe(sessionId);
+                    const result = { kind: "submitted" };
+                    return result;
+                }),
+            }),
+        },
+        hooks: {
+            start: (context) => {
+                publish = (sessionId) => Effect.runPromise(context.transact(context.observe(sessionId)));
+            },
+        },
+        projection: {
+            schema: mcpFormApprovalContract.projection.schema,
+            read: (_context, sessionId) => ({
+                pending: [...pending.entries()]
+                    .filter(([, entry]) => entry.sessionId === sessionId)
+                    .map(([id, entry]) => ({ id, approval: entry.approval })),
+            }),
+        },
+    });
+    /**
+     * Native host port, never a model or UI command. The caller supplies the
+     * actual submit result and a member-bound capability, not form JSON.
+     */
+    async function presentApproval(sessionId, submitted, approvals) {
+        const approval = await approvals.get({ recordId: submitted.recordId });
+        if (approval?.record.state !== "pending" ||
+            approval.record.requester.sessionId !== sessionId)
+            return { kind: "refused", reason: "not-pending" };
+        const existing = [...pending.entries()].find(([, entry]) => entry.sessionId === sessionId &&
+            entry.approval.record.recordId === submitted.recordId);
+        if (existing !== undefined) {
+            const [id, entry] = existing;
+            entry.approval = approval;
+            entry.approvals = approvals;
+            await publish?.(sessionId);
+            return { kind: "presented", id };
+        }
+        if (pending.size >= maximumPendingForms)
+            return { kind: "refused", reason: "capacity" };
+        const id = correlationKey();
+        pending.set(id, { sessionId, approval, approvals, answering: false });
+        await publish?.(sessionId);
+        return { kind: "presented", id };
+    }
+    function bindSession(sessionId, session, attachment) {
+        if (attachment === undefined)
+            return session;
+        return {
+            ...session,
+            extension: (id) => {
+                const client = session.extension(id);
+                return {
+                    ...client,
+                    call: (command, input) => id === mcpFormApprovalContract.id && command === "answer"
+                        ? runLocalUiCommand(attachment, sessionId, () => client.call(command, input))
+                        : client.call(command, input),
+                };
+            },
+            watch: async (input) => {
+                const stopWatching = startLocalUiWatch(attachment, sessionId);
+                if (stopWatching === undefined)
+                    return session.watch(input);
+                try {
+                    const watch = await session.watch(input);
+                    return {
+                        ...watch,
+                        close: async () => {
+                            stopWatching();
+                            await watch.close();
+                        },
+                    };
+                }
+                catch (error) {
+                    stopWatching();
+                    throw error;
+                }
+            },
+        };
+    }
+    return { extension, presentApproval, bindSession };
+}

package/dist/private-openai-claims.d.ts

@@ -0,0 +1,30 @@
+import { decodeJwt } from "jose";
+import { z } from "zod";
+/**
+ * Why a sign-in proved no person: the token or claim at fault and the claim
+ * NAMES present. Never claim values, emails, subjects or tokens.
+ */
+export declare const openAIIdentityDetailSchema: z.ZodObject<{
+    claim: z.ZodEnum<{
+        access_token: "access_token";
+        "access_token.iss": "access_token.iss";
+        "access_token.sub": "access_token.sub";
+    }>;
+    problem: z.ZodEnum<{
+        absent: "absent";
+        malformed: "malformed";
+        invalid: "invalid";
+    }>;
+    claimNames: z.ZodArray<z.ZodString>;
+    authClaimNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type OpenAIIdentityDetail = z.output<typeof openAIIdentityDetailSchema>;
+/** The person a direct-access token belongs to: its issuer and subject. */
+export declare function readOpenAIPerson(access: string, decode?: typeof decodeJwt): Readonly<{
+    kind: "person";
+    iss: string;
+    sub: string;
+}> | Readonly<{
+    kind: "unproven";
+    detail: OpenAIIdentityDetail;
+}>;

package/dist/private-openai-claims.js

@@ -0,0 +1,69 @@
+import { decodeJwt, errors } from "jose";
+import { z } from "zod";
+const identityComponent = z
+    .string()
+    .min(1)
+    .max(256)
+    .refine((value) => value.trim().length > 0);
+const authNamespace = "https://api.openai.com/auth";
+const claimObjectSchema = z.record(z.string(), z.json());
+/** At most this many claim names, each at most this long, ever cross. */
+const claimNameLimit = 32;
+const claimNameLength = 64;
+const claimNamesSchema = z
+    .array(z.string().max(claimNameLength))
+    .max(claimNameLimit);
+/**
+ * Why a sign-in proved no person: the token or claim at fault and the claim
+ * NAMES present. Never claim values, emails, subjects or tokens.
+ */
+export const openAIIdentityDetailSchema = z.strictObject({
+    claim: z.enum(["access_token", "access_token.iss", "access_token.sub"]),
+    problem: z.enum(["malformed", "absent", "invalid"]),
+    claimNames: claimNamesSchema,
+    authClaimNames: claimNamesSchema.optional(),
+});
+const names = (claims) => Object.keys(claims)
+    .slice(0, claimNameLimit)
+    .map((name) => name.slice(0, claimNameLength));
+/** Decode JWT claims; only jose's JWTInvalid means a malformed token. */
+function claimsOf(token, decode) {
+    try {
+        return claimObjectSchema.parse(decode(token));
+    }
+    catch (error) {
+        // Anything other than JWTInvalid is a real fault, not a malformed token.
+        if (error instanceof errors.JWTInvalid)
+            return undefined;
+        throw error;
+    }
+}
+/** The person a direct-access token belongs to: its issuer and subject. */
+export function readOpenAIPerson(access, decode = decodeJwt) {
+    const claims = claimsOf(access, decode);
+    if (claims === undefined)
+        return {
+            kind: "unproven",
+            detail: { claim: "access_token", problem: "malformed", claimNames: [] },
+        };
+    const claimNames = names(claims);
+    const auth = claimObjectSchema.safeParse(claims[authNamespace]);
+    const context = auth.success
+        ? { claimNames, authClaimNames: names(auth.data) }
+        : { claimNames };
+    const unproven = (claim, key) => ({
+        kind: "unproven",
+        detail: {
+            claim,
+            problem: key in claims ? "invalid" : "absent",
+            ...context,
+        },
+    });
+    const iss = identityComponent.safeParse(claims.iss);
+    if (!iss.success)
+        return unproven("access_token.iss", "iss");
+    const sub = identityComponent.safeParse(claims.sub);
+    if (!sub.success)
+        return unproven("access_token.sub", "sub");
+    return { kind: "person", iss: iss.data, sub: sub.data };
+}

package/dist/private-oyster-mcp-auth.d.ts

@@ -0,0 +1,13 @@
+import { UnauthorizedError, type AuthProvider } from "@modelcontextprotocol/client";
+/** A selected Oyster refused its key; never fall through to Hub OAuth. */
+export declare class OysterMcpKeyRejectedError extends UnauthorizedError {
+    constructor();
+}
+/** Read bounded UTF-8 stdin, then place the key in Local's existing private store. */
+export declare function saveOysterMcpKey(endpoint: URL, input: AsyncIterable<Uint8Array>, options?: {
+    credentialPath?: string;
+}): Promise<void>;
+/** Static bearer auth reads only the selected origin's credential, without discovery. */
+export declare function oysterMcpKeyAuth(endpoint: URL, options?: {
+    credentialPath?: string;
+}): AuthProvider;

package/dist/private-oyster-mcp-auth.js

@@ -0,0 +1,57 @@
+import { UnauthorizedError, } from "@modelcontextprotocol/client";
+import { z } from "zod";
+import { createPrivateCredentialStore, maximumCredentialStringLength, } from "./private-file-credential-store.js";
+import { parseFungiMcpEndpoint } from "./private-fungi-mcp-endpoint.js";
+import { capturePrivateLocalConfigRoot } from "./private-local-config-root.js";
+/** A selected Oyster refused its key; never fall through to Hub OAuth. */
+export class OysterMcpKeyRejectedError extends UnauthorizedError {
+    constructor() {
+        super("The Oyster MCP key was refused. Replace it with fungi mcp use <url> --from-file -.");
+        this.name = "OysterMcpKeyRejectedError";
+    }
+}
+function credentialId(endpoint) {
+    return `oyster-mcp:${parseFungiMcpEndpoint(endpoint).origin}`;
+}
+// Ear Tag's Oyster producer uses the oyk family and nanoid's URL-safe alphabet.
+const oysterKey = z
+    .string()
+    .trim()
+    .min(5)
+    .max(maximumCredentialStringLength)
+    .regex(/^oyk_[A-Za-z0-9_-]+$/);
+/** Read bounded UTF-8 stdin, then place the key in Local's existing private store. */
+export async function saveOysterMcpKey(endpoint, input, options = {}) {
+    const id = credentialId(endpoint);
+    const store = createPrivateCredentialStore(options.credentialPath ?? capturePrivateLocalConfigRoot().credentialPath);
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let bytes = 0;
+    let text = "";
+    for await (const chunk of input) {
+        bytes += chunk.byteLength;
+        if (bytes > maximumCredentialStringLength)
+            throw new Error("Oyster key input is too large");
+        text += decoder.decode(chunk, { stream: true });
+    }
+    text += decoder.decode();
+    const parsed = oysterKey.safeParse(text);
+    if (!parsed.success)
+        throw new Error("Expected one Oyster oyk_ key on stdin");
+    await store.modify(id, () => Promise.resolve({ type: "api_key", key: parsed.data }));
+}
+/** Static bearer auth reads only the selected origin's credential, without discovery. */
+export function oysterMcpKeyAuth(endpoint, options = {}) {
+    const id = credentialId(endpoint);
+    const store = createPrivateCredentialStore(options.credentialPath ?? capturePrivateLocalConfigRoot().credentialPath);
+    return {
+        async token() {
+            const credential = await store.read(id);
+            if (credential?.type !== "api_key" || credential.key === undefined)
+                throw new OysterMcpKeyRejectedError();
+            return credential.key;
+        },
+        onUnauthorized() {
+            return Promise.reject(new OysterMcpKeyRejectedError());
+        },
+    };
+}

package/dist/private-provider-rejection.d.ts

@@ -0,0 +1,15 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { ProviderRejection } from "@fungi.computer/mule";
+/** Evidence owned by one Local request, never inferred from assistant prose. */
+export type ModelFailureInput = Readonly<{
+    refusal?: Readonly<{
+        category: string;
+        message: string;
+    }> | undefined;
+    upstream?: AssistantMessage | undefined;
+    rejection?: ProviderRejection | undefined;
+}>;
+/** Local retries only a typed transient, never cancellation or a turn refusal. */
+export declare function modelFailureRetryable(failure: ModelFailureInput): boolean;
+/** The one owned wording for a failed Local model request. */
+export declare function modelFailureMessage(provider: string, failure: ModelFailureInput): string;

package/dist/private-provider-rejection.js

@@ -0,0 +1,24 @@
+import { isContextOverflow } from "@earendil-works/pi-ai/utils/overflow";
+/** Local retries only a typed transient, never cancellation or a turn refusal. */
+export function modelFailureRetryable(failure) {
+    return (failure.refusal === undefined &&
+        failure.upstream?.stopReason !== "aborted" &&
+        failure.rejection?.code === "provider_unavailable");
+}
+/** The one owned wording for a failed Local model request. */
+export function modelFailureMessage(provider, failure) {
+    if (failure.refusal !== undefined)
+        return `${failure.refusal.category}: ${failure.refusal.message}`;
+    // Typed subscription evidence wins over all SDK/provider wording.
+    if (failure.rejection?.code === "usage-limit-reached")
+        return `${provider} usage limit reached (usage-limit-reached). Check ChatGPT Settings > Usage, then try again later.`;
+    if (modelFailureRetryable(failure))
+        return `${provider} service unavailable. Try again shortly.`;
+    if (failure.upstream !== undefined) {
+        if (isContextOverflow(failure.upstream))
+            return `${provider} request exceeds the context window. Compact the Session or choose another model.`;
+    }
+    if (failure.rejection?.code === "provider_rejected")
+        return `${provider} rejected the model request (${failure.rejection.code}, HTTP ${String(failure.rejection.status)}). Check /login or choose another model with /model.`;
+    return `${provider} rejected the model request. Check /login or choose another model with /model.`;
+}

package/dist/private-sqlite-owner.d.ts

@@ -0,0 +1,39 @@
+import { DatabaseSync } from "node:sqlite";
+import type { SqliteOwner } from "@fungi.computer/shiitake";
+export type NativeOutput = null | number | bigint | string | Uint8Array;
+export type NativeInput = null | number | string | Uint8Array;
+/** Bun keeps its native transaction and deterministic statement-close APIs. */
+export type PrivateBunSqliteDatabase = {
+    readonly isTransaction: boolean;
+    exec: (statement: string) => void;
+    prepare: (statement: string) => {
+        all: (...bindings: NativeInput[]) => Record<string, NativeOutput>[];
+        get: (...bindings: NativeInput[]) => Record<string, NativeOutput> | undefined;
+        run: (...bindings: NativeInput[]) => {
+            changes: number | bigint;
+        };
+    };
+    transactionSync: SqliteOwner["transactionSync"];
+    close: () => void;
+};
+/** The actual Node connection or Local's explicit native Bun adapter. */
+export type PrivateSqliteDatabase = DatabaseSync | PrivateBunSqliteDatabase;
+/**
+ * A listing owns this database until its existing finally close. Bun's
+ * node:sqlite prepare/close leaves native statements alive until GC. Native
+ * close(true) on the native Bun driver explicitly finalizes every statement
+ * before releasing the connection, including when a read or decoding fails.
+ */
+export declare function openPrivateReadOnlySqliteDatabase(path: string): PrivateSqliteDatabase;
+/** Writable connections own their statements through deterministic close. */
+export declare function openPrivateWritableSqliteDatabase(path: string, timeout: number): PrivateSqliteDatabase;
+export type PrivateSqliteFailureCode = "busy" | "locked" | "corrupt" | "not_a_database" | "other";
+/** Decode the maintained drivers' structured result codes before sanitizing. */
+export declare function privateSqliteFailureCode(cause: unknown): PrivateSqliteFailureCode | undefined;
+/**
+ * Keep Local's native failure reporting around a host-supplied SQL owner.
+ * The supplied owner retains transaction mechanics and connection lifetime.
+ */
+export declare function observePrivateSqliteOwner(owner: SqliteOwner, onFailure?: (code: PrivateSqliteFailureCode) => void): SqliteOwner;
+/** Adapt one synchronous native database to Shiitake's public owner shape. */
+export declare function createPrivateSqliteOwner(database: PrivateSqliteDatabase, onFailure?: (code: PrivateSqliteFailureCode) => void): SqliteOwner;