@fungi.computer/veil 0.0.0-stage → 0.0.1

package/dist/nango-git.js

@@ -0,0 +1,125 @@
+import { VeilError } from "./index.js";
+import { bestEffortCleanup } from "./best-effort-cleanup.js";
+/** The four smart-HTTP exchanges this proxy admits for one repository, the
+ * same operation table as the Artifacts custodian. Receive-pack is admitted
+ * here; GitHub's own installation permission and branch rules decide it. */
+function gitOperation(request, url, base) {
+    for (const service of ["git-upload-pack", "git-receive-pack"]) {
+        const push = service === "git-receive-pack";
+        if (request.method === "GET" &&
+            url.pathname === `${base}/info/refs` &&
+            url.search === `?service=${service}`)
+            return {
+                push,
+                requestType: null,
+                responseType: `application/x-${service}-advertisement`,
+            };
+        if (request.method === "POST" &&
+            url.pathname === `${base}/${service}` &&
+            url.search === "")
+            return {
+                push,
+                requestType: `application/x-${service}-request`,
+                responseType: `application/x-${service}-result`,
+            };
+    }
+    return null;
+}
+/** GitHub refusals keep a typed code; vendor bodies never cross this port. */
+function upstreamRefusal(response) {
+    if (response.status === 429 ||
+        (response.status === 403 &&
+            response.headers.get("X-RateLimit-Remaining") === "0"))
+        return new VeilError("rate_limited");
+    // GitHub hides a repository outside the installation behind 404.
+    if (response.status === 404)
+        return new VeilError("repository_not_installed");
+    // A read-only installation token is refused write with 403.
+    if (response.status === 403)
+        return new VeilError("denied");
+    return new VeilError("unavailable");
+}
+/** The caller must obtain fresh Computer/repository authorization before each
+ * invocation. This adapter owns Nango control headers, not authorization state. */
+export function createNangoGitCustodian(options) {
+    if (!URL.canParse(options.serverUrl))
+        throw new VeilError("invalid_input");
+    const server = new URL(options.serverUrl);
+    if (!options.apiKey ||
+        !options.integrationId ||
+        server.username ||
+        server.password ||
+        server.search ||
+        server.hash ||
+        server.pathname !== "/" ||
+        !["http:", "https:"].includes(server.protocol))
+        throw new VeilError("invalid_input");
+    return {
+        /** Fetch, clone and push for one authorized repository. */
+        async readGit(access, request) {
+            if (access.integrationId !== options.integrationId)
+                throw new VeilError("denied");
+            const url = new URL(request.url);
+            const parts = [access.repository.owner, access.repository.name];
+            if (!access.locator ||
+                parts.some((part) => !part || part === "." || part === ".."))
+                throw new VeilError("invalid_input");
+            const base = `/${parts.map(encodeURIComponent).join("/")}.git`;
+            const operation = gitOperation(request, url, base);
+            if (url.origin !== "https://github.com" ||
+                url.username ||
+                url.password ||
+                url.hash ||
+                operation === null)
+                throw new VeilError("denied");
+            const headers = new Headers({
+                Authorization: `Bearer ${options.apiKey}`,
+                "Provider-Config-Key": options.integrationId,
+                "Connection-Id": access.locator,
+            });
+            if (operation.requestType !== null) {
+                headers.set("Content-Type", operation.requestType);
+                headers.set("Nango-Proxy-Content-Type", operation.requestType);
+            }
+            const protocol = request.headers.get("Git-Protocol");
+            if (protocol !== null)
+                headers.set("Nango-Proxy-Git-Protocol", protocol);
+            let response;
+            try {
+                request.signal.throwIfAborted();
+                response = await fetch(new URL(`/proxy${url.pathname}${url.search}`, server), {
+                    method: request.method,
+                    headers,
+                    body: operation.requestType === null ? null : request.body,
+                    signal: request.signal,
+                    redirect: "manual",
+                    // Native Node fetch requires this for a stream; Workers accepts it.
+                    duplex: "half",
+                });
+            }
+            catch (cause) {
+                throw new VeilError(request.signal.aborted ? "cancelled" : "unavailable", cause);
+            }
+            if (!response.ok) {
+                await bestEffortCleanup("nango-git-response-body", () => response.body?.cancel() ?? Promise.resolve());
+                // Reads keep their retried `unavailable`; a push names its refusal.
+                throw operation.push
+                    ? upstreamRefusal(response)
+                    : new VeilError("unavailable");
+            }
+            if (response.headers.get("Content-Type") !== operation.responseType) {
+                await bestEffortCleanup("nango-git-response-body", () => response.body?.cancel() ?? Promise.resolve());
+                throw new VeilError("invalid_response");
+            }
+            // A protected-branch or hook refusal is GitHub's own report-status
+            // inside this 200 body; the Computer's git prints it unchanged.
+            return new Response(response.body, {
+                status: response.status,
+                headers: {
+                    "Content-Type": operation.responseType,
+                    "Cache-Control": "no-store",
+                },
+            });
+        },
+    };
+}

package/dist/nango-model-keys.d.ts

@@ -0,0 +1,13 @@
+import { type ModelKeyCustodian, type ModelKeyProvider } from "./model-keys.js";
+/**
+ * Trusted host configuration. Each provider maps to a Nango API-key
+ * integration whose proxy attaches that provider's auth header.
+ * `openai-compatible` uses a bearer-token integration with a base override.
+ */
+export type NangoModelKeyOptions = Readonly<{
+    serverUrl: string;
+    apiKey: string;
+    integrations: Readonly<Partial<Record<ModelKeyProvider, string>>>;
+}>;
+/** Nango custody for Team model API keys: import once, proxy at egress, delete. */
+export declare function createNangoModelKeyCustodian(options: NangoModelKeyOptions): ModelKeyCustodian;

package/dist/nango-model-keys.js

@@ -0,0 +1,48 @@
+import { VeilError } from "./index.js";
+import { createNangoCustodyHttp } from "./nango-custody-http.js";
+import { modelKeyForwardedHeaders, modelKeyTarget, } from "./model-keys.js";
+/** Nango custody for Team model API keys: import once, proxy at egress, delete. */
+export function createNangoModelKeyCustodian(options) {
+    const http = createNangoCustodyHttp(options);
+    const integration = (provider) => {
+        const id = options.integrations[provider];
+        if (id === undefined || id.length === 0)
+            throw new VeilError("unavailable");
+        return id;
+    };
+    return {
+        async seal(input, signal) {
+            if (input.apiKey.length === 0 || input.apiKey.length > 16_384)
+                throw new VeilError("invalid_input");
+            await http.importCredential({
+                integrationId: integration(input.provider),
+                locator: input.locator,
+                teamId: input.teamId,
+                credential: input.apiKey,
+            }, signal);
+        },
+        async send(access, request) {
+            const target = modelKeyTarget(access, request);
+            const headers = new Headers();
+            for (const [name, value] of modelKeyForwardedHeaders(request))
+                headers.set(`Nango-Proxy-${name}`, value);
+            const contentType = request.headers.get("content-type");
+            if (contentType !== null)
+                headers.set("Content-Type", contentType);
+            headers.set("Provider-Config-Key", integration(access.provider));
+            headers.set("Connection-Id", access.locator);
+            headers.set("Base-Url-Override", target.origin);
+            headers.set("Retries", "0");
+            return await http.call(`/proxy${target.pathname}${target.search}`, request.signal, {
+                method: request.method,
+                headers,
+                body: request.method === "GET" ? null : request.body,
+                // Native Node fetch requires this for a stream; Workers accepts it.
+                duplex: "half",
+            });
+        },
+        async remove(access, signal) {
+            return http.removeConnection(access.locator, integration(access.provider), signal);
+        },
+    };
+}

package/dist/nango-world-seat.d.ts

@@ -0,0 +1,14 @@
+import { type WorldSeatCustodian } from "./world-seat.js";
+/**
+ * Trusted host configuration: one Nango bearer-token integration whose proxy
+ * attaches the sealed token to the seat's own endpoint.
+ */
+export type NangoWorldSeatOptions = Readonly<{
+    serverUrl: string;
+    apiKey: string;
+    integrationId: string;
+    /** The host's explicit local/dev flag: admits a loopback seat endpoint. */
+    allowLocalDev?: boolean;
+}>;
+/** Nango custody for world-seat tokens: import once, proxy at egress, delete. */
+export declare function createNangoWorldSeatCustodian(options: NangoWorldSeatOptions): WorldSeatCustodian;

package/dist/nango-world-seat.js

@@ -0,0 +1,47 @@
+import { VeilError } from "./index.js";
+import { createNangoCustodyHttp } from "./nango-custody-http.js";
+import { WORLD_SEAT_TOKEN_MAX, worldSeatEndpoint, worldSeatForwardedHeaders, worldSeatTarget, } from "./world-seat.js";
+/** Nango custody for world-seat tokens: import once, proxy at egress, delete. */
+export function createNangoWorldSeatCustodian(options) {
+    if (!options.integrationId)
+        throw new VeilError("invalid_input");
+    const http = createNangoCustodyHttp(options);
+    return {
+        async seal(input, signal) {
+            worldSeatEndpoint(input.endpoint, {
+                allowLocalDev: options.allowLocalDev === true,
+            });
+            if (input.token.length === 0 || input.token.length > WORLD_SEAT_TOKEN_MAX)
+                throw new VeilError("invalid_input");
+            await http.importCredential({
+                integrationId: options.integrationId,
+                locator: input.locator,
+                teamId: input.teamId,
+                credential: input.token,
+            }, signal);
+        },
+        async send(access, request) {
+            const target = worldSeatTarget(access, request);
+            const headers = new Headers();
+            for (const [name, value] of worldSeatForwardedHeaders(request))
+                headers.set(`Nango-Proxy-${name}`, value);
+            const contentType = request.headers.get("content-type");
+            if (contentType !== null)
+                headers.set("Content-Type", contentType);
+            headers.set("Provider-Config-Key", options.integrationId);
+            headers.set("Connection-Id", access.locator);
+            headers.set("Base-Url-Override", target.origin);
+            headers.set("Retries", "0");
+            return await http.call(`/proxy${target.pathname}`, request.signal, {
+                method: request.method,
+                headers,
+                body: request.method === "POST" ? request.body : null,
+                // Native Node fetch requires this for a stream; Workers accepts it.
+                duplex: "half",
+            });
+        },
+        async remove(access, signal) {
+            return http.removeConnection(access.locator, options.integrationId, signal);
+        },
+    };
+}

package/dist/nango.d.ts

@@ -0,0 +1,16 @@
+import { type CredentialCustodian } from "./index.js";
+/** Trusted host configuration; never supplied by a model or Connect browser.
+ * The public Connect document and API URLs are independent of the internal
+ * serverUrl the Hub uses for custody. */
+export type NangoCustodianOptions = Readonly<{
+    serverUrl: string;
+    apiKey: string;
+    webhookSigningKey: string;
+    integrationId: string;
+    connectBaseUrl: string;
+    publicApiUrl: string;
+    /** Deadline for one custodian request and its body; a miss is `unavailable`. */
+    requestTimeoutMs?: number;
+}>;
+/** Pinned Nango Connect/connection REST contract and maintained raw-body verifier. */
+export declare function createNangoCustodian(options: NangoCustodianOptions): CredentialCustodian;

package/dist/nango.js

@@ -0,0 +1,300 @@
+import * as Schema from "effect/Schema";
+import * as Exit from "effect/Exit";
+import { VeilError, } from "./index.js";
+const text = Schema.NonEmptyString;
+const tagsSchema = Schema.Struct({
+    veil_team_id: text,
+    veil_attempt_id: text,
+    veil_principal_id: text,
+});
+const sessionSchema = Schema.Struct({
+    data: Schema.Struct({
+        token: text,
+        connect_link: text,
+        expires_at: Schema.DateFromString,
+    }),
+});
+const webhookEnvelopeSchema = Schema.Struct({
+    type: text,
+    operation: Schema.optional(text),
+});
+/** Nango auth webhook fields shared by creation and refresh notifications. */
+const authWebhookSchema = Schema.Struct({
+    type: Schema.Literal("auth"),
+    operation: Schema.Literals(["creation", "refresh"]),
+    success: Schema.Boolean,
+    connectionId: text,
+    providerConfigKey: text,
+    tags: tagsSchema,
+    endUser: Schema.Struct({ endUserId: text, organizationId: text }),
+});
+/** GitHub's own unauthorized body, as relayed verbatim by the Nango proxy.
+ * Nango's own errors use an `error` envelope and remain unavailable. */
+const providerUnauthorizedSchema = Schema.Struct({
+    message: text,
+    documentation_url: text,
+});
+const connectionSchema = Schema.Struct({
+    connection_id: text,
+    provider_config_key: text,
+    tags: tagsSchema,
+    end_user: Schema.Struct({
+        id: text,
+        organization: Schema.Struct({ id: text }),
+    }),
+});
+const connectionsSchema = Schema.Struct({
+    connections: Schema.Array(connectionSchema),
+});
+const deletedSchema = Schema.Struct({ success: Schema.Literal(true) });
+const absentSchema = Schema.Struct({
+    error: Schema.Struct({ code: Schema.Literal("unknown_connection") }),
+});
+/** A custodian that stops answering is an outage, retried later, never a dead credential. */
+const defaultRequestTimeoutMs = 10_000;
+function publicUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new VeilError("invalid_input");
+    }
+    if ((url.protocol !== "https:" && url.protocol !== "http:") ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash)
+        throw new VeilError("invalid_input");
+    return url;
+}
+/** The Connect document handed to browsers: Nango's issued link, confined to
+ * the configured Connect UI and pinned to the configured public API. */
+function connectDocument(session, base, api) {
+    let document;
+    try {
+        document = new URL(session.connectUrl);
+    }
+    catch {
+        throw new VeilError("invalid_response");
+    }
+    if (document.origin !== base.origin ||
+        document.pathname !== base.pathname ||
+        document.username ||
+        document.password ||
+        document.hash ||
+        document.searchParams.get("session_token") !== session.token)
+        throw new VeilError("invalid_response");
+    document.searchParams.set("apiURL", api.href);
+    return document.href;
+}
+/** Pinned Nango Connect/connection REST contract and maintained raw-body verifier. */
+export function createNangoCustodian(options) {
+    let server;
+    try {
+        server = new URL(options.serverUrl);
+    }
+    catch {
+        throw new VeilError("invalid_input");
+    }
+    if (!options.apiKey ||
+        !options.webhookSigningKey ||
+        !options.integrationId ||
+        server.username ||
+        server.password ||
+        server.search ||
+        server.hash ||
+        server.pathname !== "/" ||
+        (server.protocol !== "https:" && server.protocol !== "http:"))
+        throw new VeilError("invalid_input");
+    const connectBase = publicUrl(options.connectBaseUrl);
+    if (!connectBase.pathname.endsWith("/"))
+        connectBase.pathname += "/";
+    const publicApi = publicUrl(options.publicApiUrl);
+    const decode = (schema, raw, code = "invalid_response") => {
+        try {
+            return Schema.decodeUnknownSync(Schema.fromJsonString(schema))(raw);
+        }
+        catch {
+            throw new VeilError(code);
+        }
+    };
+    const requestTimeoutMs = options.requestTimeoutMs ?? defaultRequestTimeoutMs;
+    const request = async (path, signal, init = {}) => {
+        try {
+            signal.throwIfAborted();
+            const headers = new Headers(init.headers);
+            headers.set("Authorization", `Bearer ${options.apiKey}`);
+            // The deadline also aborts the body stream that `body` reads next.
+            return await fetch(new URL(path, server), {
+                ...init,
+                headers,
+                signal: AbortSignal.any([
+                    signal,
+                    AbortSignal.timeout(requestTimeoutMs),
+                ]),
+                redirect: "manual",
+            });
+        }
+        catch {
+            throw new VeilError(signal.aborted ? "cancelled" : "unavailable");
+        }
+    };
+    const body = async (response, signal) => {
+        try {
+            return await response.text();
+        }
+        catch {
+            throw new VeilError(signal.aborted ? "cancelled" : "unavailable");
+        }
+    };
+    const requireSuccess = (response) => {
+        if (!response.ok)
+            throw new VeilError("unavailable");
+    };
+    const tags = (teamId, attemptId, principalId) => ({
+        veil_team_id: teamId,
+        veil_attempt_id: attemptId,
+        veil_principal_id: principalId,
+    });
+    const completion = (row, integrationId, locator) => ({
+        teamId: row.veil_team_id,
+        attemptId: row.veil_attempt_id,
+        principalId: row.veil_principal_id,
+        integrationId,
+        locator,
+    });
+    /**
+     * Maintained HMAC over the raw body first; only then decode the operation.
+     * The Nango SDK (and its HTTP client) loads with the first webhook rather
+     * than with every Worker that hosts a custodian.
+     */
+    const verifyWebhook = (rawBody, signature) => import("@nangohq/node").then(({ Nango }) => {
+        const verifier = new Nango({
+            host: server.origin,
+            apiKey: options.apiKey,
+            webhookSigningKey: options.webhookSigningKey,
+        });
+        if (!verifier.verifyIncomingWebhookRequest(rawBody, {
+            "X-Nango-Hmac-Sha256": signature,
+        }))
+            throw new VeilError("invalid_completion");
+        const envelope = decode(webhookEnvelopeSchema, rawBody, "invalid_completion");
+        if (envelope.type !== "auth" ||
+            (envelope.operation !== "creation" && envelope.operation !== "refresh"))
+            throw new VeilError("unsupported");
+        const row = decode(authWebhookSchema, rawBody, "invalid_completion");
+        // Handled: a successful creation, or a failed credential refresh.
+        if (row.success !== (row.operation === "creation"))
+            throw new VeilError("unsupported");
+        if (row.providerConfigKey !== options.integrationId ||
+            row.endUser.endUserId !== row.tags.veil_principal_id ||
+            row.endUser.organizationId !== row.tags.veil_team_id)
+            throw new VeilError("invalid_completion");
+        return {
+            operation: row.operation === "creation" ? "creation" : "refresh_failed",
+            completion: completion(row.tags, row.providerConfigKey, row.connectionId),
+        };
+    });
+    return {
+        async openSession(input, signal) {
+            if (input.integrationId !== options.integrationId)
+                throw new VeilError("denied");
+            const response = await request("/connect/sessions", signal, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    allowed_integrations: [options.integrationId],
+                    end_user: { id: input.principalId },
+                    organization: { id: input.teamId },
+                    tags: tags(input.teamId, input.attemptId, input.principalId),
+                }),
+            });
+            requireSuccess(response);
+            const { data } = decode(sessionSchema, await body(response, signal));
+            return {
+                token: data.token,
+                connectUrl: connectDocument({ token: data.token, connectUrl: data.connect_link }, connectBase, publicApi),
+                expiresAt: data.expires_at.getTime(),
+            };
+        },
+        verifyWebhook,
+        async verifyCompletion(rawBody, signature) {
+            const event = await verifyWebhook(rawBody, signature);
+            if (event.operation !== "creation")
+                throw new VeilError("unsupported");
+            return event.completion;
+        },
+        async findCompletion(attempt, signal) {
+            if (attempt.integrationId !== options.integrationId)
+                throw new VeilError("denied");
+            const expected = tags(attempt.teamId, attempt.attemptId, attempt.actorUserId);
+            const query = new URLSearchParams({
+                integrationId: options.integrationId,
+                endUserId: attempt.actorUserId,
+                endUserOrganizationId: attempt.teamId,
+                limit: "2",
+                page: "0",
+            });
+            for (const [key, value] of Object.entries(expected))
+                query.set(`tags[${key}]`, value);
+            const response = await request(`/connections?${query.toString()}`, signal);
+            requireSuccess(response);
+            const { connections } = decode(connectionsSchema, await body(response, signal));
+            // Selected server filters before LIMIT; two rows are sufficient to prove ambiguity.
+            for (const row of connections) {
+                if (row.provider_config_key !== options.integrationId ||
+                    row.end_user.id !== attempt.actorUserId ||
+                    row.end_user.organization.id !== attempt.teamId ||
+                    row.tags.veil_team_id !== attempt.teamId ||
+                    row.tags.veil_attempt_id !== attempt.attemptId ||
+                    row.tags.veil_principal_id !== attempt.actorUserId)
+                    throw new VeilError("invalid_response");
+            }
+            if (connections.length === 0)
+                return { status: "unresolved" };
+            if (connections.length !== 1)
+                return { status: "ambiguous" };
+            const row = connections[0];
+            if (!row)
+                throw new VeilError("invalid_response");
+            return {
+                status: "verified",
+                completion: completion(row.tags, row.provider_config_key, row.connection_id),
+            };
+        },
+        async deleteConnection(locator, signal) {
+            const query = new URLSearchParams({
+                provider_config_key: options.integrationId,
+            });
+            const response = await request(`/connections/${encodeURIComponent(locator)}?${query.toString()}`, signal, { method: "DELETE" });
+            const raw = await body(response, signal);
+            // This pinned public endpoint reports absent as HTTP400, not a generic404.
+            if (response.status === 400) {
+                decode(absentSchema, raw);
+                return "absent";
+            }
+            requireSuccess(response);
+            decode(deletedSchema, raw);
+            return "deleted";
+        },
+        async readRepository(access, signal) {
+            // WHATWG URL normalizes dot segments, including percent-encoded dots.
+            if ([access.repository.owner, access.repository.name].some((part) => part === "." || part === ".."))
+                throw new VeilError("invalid_input");
+            const path = `/proxy/repos/${encodeURIComponent(access.repository.owner)}/${encodeURIComponent(access.repository.name)}`;
+            const response = await request(path, signal, {
+                headers: {
+                    "Connection-Id": access.locator,
+                    "Provider-Config-Key": options.integrationId,
+                },
+            });
+            if (response.status === 401) {
+                const evidence = Schema.decodeUnknownExit(Schema.fromJsonString(providerUnauthorizedSchema))(await body(response, signal));
+                throw new VeilError(Exit.isSuccess(evidence) ? "reconnect_required" : "unavailable");
+            }
+            requireSuccess(response);
+            return await body(response, signal);
+        },
+    };
+}

package/dist/openapi-contract.d.ts

@@ -0,0 +1,64 @@
+import type { HostResolver } from "./model-key-network.js";
+import type { PublicEgressPolicy } from "./public-egress-policy.js";
+import type { PublicConnect } from "./public-fetch.js";
+/** Only the trusted Team owner supplies access and selects a stored operation. */
+export type OpenApiAuth = Readonly<{
+    kind: "none";
+}> | Readonly<{
+    kind: "api_key_header" | "api_key_query";
+    param: string;
+}> | Readonly<{
+    kind: "bearer";
+}> | Readonly<{
+    kind: "oauth";
+    provider: string;
+    locator: string;
+}>;
+export type OpenApiAccess = Readonly<{
+    teamId: string;
+    connectorId: string;
+    baseUrl: string;
+    auth: OpenApiAuth;
+}>;
+export type OpenApiCredentialAddress = Readonly<{
+    teamId: string;
+    connectorId: string;
+}>;
+/** The host persists ciphertext only. Never give this port to an Agent or browser. */
+export type OpenApiCredentialStore = Readonly<{
+    read: (address: OpenApiCredentialAddress, signal: AbortSignal) => Promise<string | null>;
+    write: (address: OpenApiCredentialAddress, sealed: string, signal: AbortSignal) => Promise<void>;
+    remove: (address: OpenApiCredentialAddress, signal: AbortSignal) => Promise<"deleted" | "absent">;
+}>;
+/** Host-configured OAuth only: its provider fixes the upstream base and owns Nango proxying. */
+export type OpenApiOAuthProvider = Readonly<{
+    baseUrl: string;
+    send: (teamId: string, locator: string, request: Request) => Promise<Response>;
+}>;
+export type OpenApiCredentialKeyring = Readonly<{
+    activeKeyId: string;
+    keys: Readonly<Record<string, string>>;
+}>;
+export type OpenApiDoorOptions = Readonly<{
+    connect: PublicConnect;
+    resolve: HostResolver;
+    networkPolicy?: PublicEgressPolicy;
+    /** Dedicated 32-byte base64url keys; active key seals, retained keys open. */
+    custody?: Readonly<{
+        keys: OpenApiCredentialKeyring;
+        store: OpenApiCredentialStore;
+    }>;
+    oauthProviders?: Readonly<Record<string, OpenApiOAuthProvider>>;
+}>;
+export type OpenApiRefusal = "denied" | "invalid_input" | "invalid_response" | "too_large" | "timeout" | "cancelled" | "unavailable" | "credentials_missing" | "oauth_not_configured" | "upstream_status";
+/** Fixed codes only: upstream bodies, URLs and credential bytes never enter errors. */
+export declare class OpenApiError extends Error {
+    readonly code: OpenApiRefusal;
+    readonly status?: number | undefined;
+    constructor(code: OpenApiRefusal, status?: number | undefined);
+}
+export type OpenApiDoor = Readonly<{
+    seal: (access: OpenApiAccess, credential: string, signal: AbortSignal) => Promise<void>;
+    send: (access: OpenApiAccess, request: Request, declaredHeaders?: readonly string[]) => Promise<Response>;
+    remove: (address: OpenApiCredentialAddress, signal: AbortSignal) => Promise<"deleted" | "absent">;
+}>;

package/dist/openapi-contract.js

@@ -0,0 +1,11 @@
+/** Fixed codes only: upstream bodies, URLs and credential bytes never enter errors. */
+export class OpenApiError extends Error {
+    code;
+    status;
+    constructor(code, status) {
+        super(code);
+        this.code = code;
+        this.status = status;
+        this.name = "OpenApiError";
+    }
+}

package/dist/openapi-effect.d.ts

@@ -0,0 +1,9 @@
+import * as Effect from "effect/Effect";
+import { OpenApiError, type OpenApiAccess, type OpenApiDoorOptions, type OpenApiCredentialAddress } from "./openapi-contract.js";
+/** Canonical Effect policy; Promises appear only at socket, crypto and storage adapters. */
+export type OpenApiEffects = Readonly<{
+    seal: (access: OpenApiAccess, credential: string) => Effect.Effect<void, OpenApiError>;
+    remove: (address: OpenApiCredentialAddress) => Effect.Effect<"deleted" | "absent", OpenApiError>;
+    send: (access: OpenApiAccess, request: Request, declaredHeaders?: readonly string[]) => Effect.Effect<Response, OpenApiError>;
+}>;
+export declare function createOpenApiEffects(options: OpenApiDoorOptions): OpenApiEffects;