@anchrd/intel-api 0.2.0

package/dist/adapters/db/db.types.d.ts

@@ -0,0 +1,16 @@
+export interface D1Result<T = unknown> {
+    results?: T[];
+    meta?: {
+        changes?: number;
+    };
+}
+export interface D1Statement {
+    bind(...values: unknown[]): D1Statement;
+    first<T = Record<string, unknown>>(): Promise<T | null>;
+    all<T = Record<string, unknown>>(): Promise<D1Result<T>>;
+    run<T = Record<string, unknown>>(): Promise<D1Result<T>>;
+}
+export interface D1Database {
+    prepare(query: string): D1Statement;
+    batch<T = unknown>(statements: D1Statement[]): Promise<D1Result<T>[]>;
+}

package/dist/adapters/db/db.types.js

@@ -0,0 +1 @@
+export {};

package/dist/adapters/document-converter/document-converter.d.ts

@@ -0,0 +1,2 @@
+import type { DocumentConverter, MarkdownAiBinding } from "./document-converter.types.js";
+export declare function createDocumentConverter(ai: MarkdownAiBinding): DocumentConverter;

package/dist/adapters/document-converter/document-converter.js

@@ -0,0 +1,25 @@
+function converted(result) {
+    const item = Array.isArray(result) ? result[0] : result;
+    if (typeof item !== "object" ||
+        item === null ||
+        !("format" in item) ||
+        (item.format !== "markdown" && item.format !== "text") ||
+        !("data" in item) ||
+        typeof item.data !== "string") {
+        const detail = typeof item === "object" && item !== null && "error" in item && typeof item.error === "string"
+            ? item.error
+            : "Markdown conversion returned an invalid response";
+        throw new Error(detail);
+    }
+    return item.data;
+}
+export function createDocumentConverter(ai) {
+    return {
+        async convert(name, mediaType, content) {
+            return converted(await ai.toMarkdown({
+                name,
+                blob: new Blob([content], { type: mediaType }),
+            }));
+        },
+    };
+}

package/dist/adapters/document-converter/document-converter.types.d.ts

@@ -0,0 +1,9 @@
+export interface MarkdownAiBinding {
+    toMarkdown(input: {
+        name: string;
+        blob: Blob;
+    }): Promise<unknown>;
+}
+export interface DocumentConverter {
+    convert(name: string, mediaType: string, content: ArrayBuffer): Promise<string>;
+}

package/dist/adapters/document-converter/document-converter.types.js

@@ -0,0 +1 @@
+export {};

package/dist/adapters/flow-runtime/flow-runtime.d.ts

@@ -0,0 +1,3 @@
+import type { FlowRuntime } from "../../flows/flows.types.js";
+import type { WorkflowBinding } from "./flow-runtime.types.js";
+export declare function createFlowRuntime(binding: WorkflowBinding): FlowRuntime;

package/dist/adapters/flow-runtime/flow-runtime.js

@@ -0,0 +1,22 @@
+export function createFlowRuntime(binding) {
+    return {
+        async start(runId) {
+            try {
+                await binding.create({ id: runId, params: { runId } });
+            }
+            catch (error) {
+                try {
+                    const existing = await binding.get(runId);
+                    await existing.status();
+                }
+                catch {
+                    throw error;
+                }
+            }
+        },
+        async signal(runId) {
+            const instance = await binding.get(runId);
+            await instance.sendEvent({ type: "advance", payload: { runId } });
+        },
+    };
+}

package/dist/adapters/flow-runtime/flow-runtime.types.d.ts

@@ -0,0 +1,19 @@
+export interface WorkflowBinding {
+    create(options: {
+        id: string;
+        params: {
+            runId: string;
+        };
+    }): Promise<{
+        id: string;
+    }>;
+    get(id: string): Promise<{
+        status(): Promise<{
+            status: string;
+        }>;
+        sendEvent(event: {
+            type: string;
+            payload: unknown;
+        }): Promise<void>;
+    }>;
+}

package/dist/adapters/flow-runtime/flow-runtime.types.js

@@ -0,0 +1 @@
+export {};

package/dist/adapters/index-queue/index-queue.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import type { QueueProducer } from "./index-queue.types.js";
+export declare const IndexMessage: z.ZodObject<{
+    type: z.ZodLiteral<"knowledge.version">;
+    versionId: z.ZodString;
+}, z.core.$strict>;
+export type IndexMessage = z.infer<typeof IndexMessage>;
+export declare function createIndexQueue(queue: QueueProducer<IndexMessage>): {
+    enqueue(versionId: string): Promise<void>;
+};

package/dist/adapters/index-queue/index-queue.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export const IndexMessage = z.strictObject({
+    type: z.literal("knowledge.version"),
+    versionId: z.string().min(1),
+});
+export function createIndexQueue(queue) {
+    return {
+        async enqueue(versionId) {
+            await queue.send({ type: "knowledge.version", versionId });
+        },
+    };
+}

package/dist/adapters/index-queue/index-queue.types.d.ts

@@ -0,0 +1,11 @@
+export interface QueueProducer<T> {
+    send(message: T): Promise<void>;
+}
+export interface QueueMessage<T> {
+    body: T;
+    ack(): void;
+    retry(): void;
+}
+export interface QueueBatch<T> {
+    messages: QueueMessage<T>[];
+}

package/dist/adapters/index-queue/index-queue.types.js

@@ -0,0 +1 @@
+export {};

package/dist/adapters/json-schema/json-schema.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDeps } from "../../tools/tools.types.js";
+export declare function createJsonSchemaValidator(): ToolDeps["validate"];

package/dist/adapters/json-schema/json-schema.js

@@ -0,0 +1,31 @@
+import Ajv, {} from "ajv";
+// Tool schemas come from remote catalogs and are therefore untrusted: allErrors lets a crafted
+// schema amplify validation work, and Ajv keeps every compiled schema for the life of the isolate.
+const MaxCompiledSchemas = 200;
+export function createJsonSchemaValidator() {
+    const ajv = new Ajv({ allErrors: false, strict: false });
+    const compiled = new Map();
+    return (schema, value) => {
+        try {
+            const key = JSON.stringify(schema);
+            let validate = compiled.get(key);
+            if (!validate) {
+                if (compiled.size >= MaxCompiledSchemas) {
+                    compiled.clear();
+                    ajv.removeSchema();
+                }
+                validate = ajv.compile(schema);
+                compiled.set(key, validate);
+            }
+            if (validate(value))
+                return { valid: true };
+            return {
+                valid: false,
+                detail: ajv.errorsText(validate.errors, { separator: "; " }).slice(0, 2_000),
+            };
+        }
+        catch {
+            return { valid: false, detail: "The cached tool schema is invalid" };
+        }
+    };
+}

package/dist/adapters/openid/openid.d.ts

@@ -0,0 +1,5 @@
+import type { OAuthPort } from "../../auth/auth.types.js";
+export declare function createOpenId(deps: {
+    fetch: typeof fetch;
+    allowInsecure?: boolean;
+}): OAuthPort;

package/dist/adapters/openid/openid.js

@@ -0,0 +1,159 @@
+import { ToolSourceUrl } from "@anchrd/intel-contract";
+import * as client from "openid-client";
+import { z } from "zod";
+const ProtectedResource = z.looseObject({
+    resource: ToolSourceUrl,
+    authorization_servers: z.array(ToolSourceUrl).min(1),
+});
+function metadataCandidates(resourceUrl, challenge) {
+    const resource = new URL(resourceUrl);
+    const path = resource.pathname === "/" ? "" : resource.pathname.replace(/\/+$/, "");
+    let challengeUrl = null;
+    try {
+        challengeUrl = challenge ? new URL(challenge, resource) : null;
+    }
+    catch {
+        challengeUrl = null;
+    }
+    return [
+        ...(challengeUrl?.origin === resource.origin ? [challengeUrl.href] : []),
+        `${resource.origin}/.well-known/oauth-protected-resource${path}`,
+        `${resource.origin}/.well-known/oauth-protected-resource`,
+    ].filter((value, index, values) => values.indexOf(value) === index);
+}
+function resourceMetadataChallenge(header) {
+    return header?.match(/resource_metadata="([^"]+)"/i)?.[1] ?? null;
+}
+function isCloudflareAccess(issuer) {
+    return new URL(issuer).hostname.endsWith(".cloudflareaccess.com");
+}
+function tokenResponse(tokens) {
+    return {
+        accessToken: tokens.access_token,
+        expiresIn: tokens.expires_in ?? 3_600,
+        ...(tokens.refresh_token ? { refreshToken: tokens.refresh_token } : {}),
+    };
+}
+// Discovery, token and probe requests run inside the login and connect paths. Without a deadline a
+// hanging issuer would hold the request open until the platform kills it.
+const RequestTimeoutMs = 10_000;
+export function createOpenId(deps) {
+    const customFetch = async (url, options) => {
+        const init = options;
+        const deadline = AbortSignal.timeout(RequestTimeoutMs);
+        // The library may pass its own signal. Spreading init last would drop the deadline, spreading it
+        // first would drop the caller's cancellation, so both have to abort the request.
+        return await deps.fetch(url, {
+            ...init,
+            signal: init.signal ? AbortSignal.any([init.signal, deadline]) : deadline,
+        });
+    };
+    const configurations = new Map();
+    function options(issuer) {
+        const insecure = new URL(issuer).protocol === "http:";
+        if (insecure && !deps.allowInsecure) {
+            throw new Error("Insecure OAuth issuers require ALLOW_INSECURE_OAUTH=true");
+        }
+        return {
+            [client.customFetch]: customFetch,
+            ...(insecure ? { execute: [client.allowInsecureRequests] } : {}),
+        };
+    }
+    async function discover(issuer, clientId) {
+        const key = `${issuer}#${clientId}`;
+        let configuration = configurations.get(key);
+        if (!configuration) {
+            configuration = client.discovery(new URL(issuer), clientId, { token_endpoint_auth_method: "none" }, client.None(), options(issuer));
+            configurations.set(key, configuration);
+            void configuration.catch(() => configurations.delete(key));
+        }
+        return await configuration;
+    }
+    return {
+        async discoverResource(resourceUrl) {
+            const probe = await deps
+                .fetch(resourceUrl, {
+                method: "POST",
+                signal: AbortSignal.timeout(RequestTimeoutMs),
+                headers: {
+                    accept: "application/json, text/event-stream",
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: "intel-oauth-discovery",
+                    method: "initialize",
+                    params: {
+                        protocolVersion: "2025-11-25",
+                        capabilities: {},
+                        clientInfo: { name: "intel", version: "0.1.0" },
+                    },
+                }),
+            })
+                .catch(() => null);
+            const candidates = metadataCandidates(resourceUrl, resourceMetadataChallenge(probe?.headers.get("www-authenticate") ?? null));
+            for (const candidate of candidates) {
+                const response = await deps
+                    .fetch(candidate, {
+                    signal: AbortSignal.timeout(RequestTimeoutMs),
+                    headers: { accept: "application/json" },
+                })
+                    .catch(() => null);
+                if (!response?.ok)
+                    continue;
+                const metadata = ProtectedResource.safeParse(await response.json().catch(() => null));
+                if (!metadata.success)
+                    continue;
+                if (new URL(metadata.data.resource).href !== new URL(resourceUrl).href)
+                    continue;
+                const issuer = metadata.data.authorization_servers[0];
+                if (issuer) {
+                    return {
+                        resource: metadata.data.resource,
+                        issuer,
+                        ...(isCloudflareAccess(issuer) ? {} : { scope: "openid profile email offline_access" }),
+                    };
+                }
+            }
+            throw new Error("MCP resource did not publish valid OAuth metadata");
+        },
+        async register(input) {
+            const configuration = await client.dynamicClientRegistration(new URL(input.issuer), {
+                client_name: input.clientName,
+                redirect_uris: [input.redirectUri],
+                response_types: ["code"],
+                grant_types: ["authorization_code"],
+                ...(isCloudflareAccess(input.issuer)
+                    ? {}
+                    : { scope: "openid profile email offline_access" }),
+                token_endpoint_auth_method: "none",
+                ...(isCloudflareAccess(input.issuer) ? { resource: input.resource } : {}),
+            }, client.None(), options(input.issuer));
+            return configuration.clientMetadata().client_id;
+        },
+        async authorizationUrl(input) {
+            const configuration = await discover(input.issuer, input.clientId);
+            return client.buildAuthorizationUrl(configuration, {
+                response_type: "code",
+                redirect_uri: input.redirectUri,
+                ...(input.scope ? { scope: input.scope } : {}),
+                resource: input.resource,
+                code_challenge: input.codeChallenge,
+                code_challenge_method: "S256",
+                state: input.state,
+            });
+        },
+        async exchange(input) {
+            const configuration = await discover(input.issuer, input.clientId);
+            const tokens = await client.authorizationCodeGrant(configuration, input.callbackUrl, { pkceCodeVerifier: input.codeVerifier, expectedState: input.state }, { resource: input.resource });
+            return tokenResponse(tokens);
+        },
+        async refresh(input) {
+            const configuration = await discover(input.issuer, input.clientId);
+            const tokens = await client.refreshTokenGrant(configuration, input.refreshToken, {
+                resource: input.resource,
+            });
+            return tokenResponse(tokens);
+        },
+    };
+}

package/dist/adapters/portal-tokens/portal-tokens.d.ts

@@ -0,0 +1,8 @@
+import type { PortalTokenStore } from "../../tools/tools.types.js";
+import type { D1Database } from "../db/db.types.js";
+export declare function createPortalTokenStore(deps: {
+    db: D1Database;
+    secret: string;
+    crypto: Crypto;
+    now(): Date;
+}): PortalTokenStore;

package/dist/adapters/portal-tokens/portal-tokens.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+const StoredToken = z.strictObject({
+    version: z.literal(1),
+    accessToken: z.string().min(1),
+    refreshToken: z.string().min(1).nullable(),
+    expiresAt: z.number().int().positive(),
+    issuer: z.url(),
+    clientId: z.string().min(1),
+    resource: z.url(),
+});
+// Bound to this purpose so a sealed value cannot be replayed as a session cookie and vice versa.
+const additionalData = new TextEncoder().encode("anchrd-intel-portal-token-v1");
+function encode(bytes) {
+    let value = "";
+    for (const byte of bytes)
+        value += String.fromCharCode(byte);
+    return btoa(value);
+}
+function decode(value) {
+    return Uint8Array.from(atob(value), (character) => character.charCodeAt(0));
+}
+export function createPortalTokenStore(deps) {
+    if (new TextEncoder().encode(deps.secret).byteLength < 32) {
+        throw new Error("INTEL_SESSION_SECRET must contain at least 32 bytes");
+    }
+    const key = deps.crypto.subtle
+        .digest("SHA-256", new TextEncoder().encode(deps.secret))
+        .then((hash) => deps.crypto.subtle.importKey("raw", hash, "AES-GCM", false, ["encrypt", "decrypt"]));
+    return {
+        async read(userId) {
+            const row = await deps.db
+                .prepare("SELECT sealed FROM portal_tokens WHERE user_id = ?")
+                .bind(userId)
+                .first();
+            if (!row)
+                return null;
+            try {
+                const raw = decode(row.sealed);
+                const plaintext = await deps.crypto.subtle.decrypt({ name: "AES-GCM", iv: raw.subarray(0, 12), additionalData }, await key, raw.subarray(12));
+                const parsed = StoredToken.parse(JSON.parse(new TextDecoder().decode(plaintext)));
+                const { version: _version, ...token } = parsed;
+                return token;
+            }
+            catch {
+                // A row that no longer decrypts (rotated secret, tampering) is treated as absent so the
+                // user is asked to reconnect instead of hitting an opaque failure on every call.
+                return null;
+            }
+        },
+        async write(userId, token) {
+            const iv = deps.crypto.getRandomValues(new Uint8Array(12));
+            const encrypted = new Uint8Array(await deps.crypto.subtle.encrypt({ name: "AES-GCM", iv, additionalData }, await key, new TextEncoder().encode(JSON.stringify({ version: 1, ...token }))));
+            const sealed = new Uint8Array(iv.byteLength + encrypted.byteLength);
+            sealed.set(iv);
+            sealed.set(encrypted, iv.byteLength);
+            const timestamp = deps.now().toISOString();
+            await deps.db
+                .prepare(`INSERT INTO portal_tokens (user_id, sealed, expires_at, updated_at)
+          VALUES (?, ?, ?, ?)
+          ON CONFLICT(user_id) DO UPDATE SET
+            sealed = excluded.sealed,
+            expires_at = excluded.expires_at,
+            updated_at = excluded.updated_at`)
+                .bind(userId, encode(sealed), new Date(token.expiresAt).toISOString(), timestamp)
+                .run();
+        },
+        async clear(userId) {
+            await deps.db.prepare("DELETE FROM portal_tokens WHERE user_id = ?").bind(userId).run();
+        },
+    };
+}

package/dist/adapters/remote-tools/remote-tools.d.ts

@@ -0,0 +1,5 @@
+import type { RemoteTools } from "../../tools/tools.types.js";
+export interface RemoteToolsDeps {
+    fetch: (url: string | URL, init?: RequestInit) => Promise<Response>;
+}
+export declare function createRemoteTools(deps: RemoteToolsDeps): RemoteTools;

package/dist/adapters/remote-tools/remote-tools.js

@@ -0,0 +1,109 @@
+import { ToolTestResult } from "@anchrd/intel-contract";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+function responseWithLimit(response, maxBytes) {
+    const length = Number(response.headers.get("content-length"));
+    if (Number.isFinite(length) && length > maxBytes) {
+        void response.body?.cancel();
+        throw new Error(`Remote MCP response exceeded ${maxBytes} bytes`);
+    }
+    if (!response.body)
+        return response;
+    let received = 0;
+    const bounded = response.body.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            received += chunk.byteLength;
+            if (received > maxBytes) {
+                controller.error(new Error(`Remote MCP response exceeded ${maxBytes} bytes`));
+                return;
+            }
+            controller.enqueue(chunk);
+        },
+    }));
+    return new Response(bounded, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+export function createRemoteTools(deps) {
+    async function connected(url, accessToken, signal, maxBytes, work) {
+        const client = new Client({ name: "intel-tools", version: "0.1.0" });
+        const transport = new StreamableHTTPClientTransport(new URL(url), {
+            fetch: async (input, init) => responseWithLimit(await deps.fetch(input, {
+                ...init,
+                signal: init?.signal ? AbortSignal.any([signal, init.signal]) : signal,
+            }), maxBytes),
+            requestInit: { headers: { authorization: `Bearer ${accessToken}` }, signal },
+        });
+        try {
+            // The SDK's transport and client currently disagree under exactOptionalPropertyTypes.
+            await client.connect(transport);
+            return await work(client);
+        }
+        finally {
+            await client.close().catch(() => undefined);
+        }
+    }
+    return {
+        async list(url, accessToken, signal) {
+            return await connected(url, accessToken, signal, 5_000_000, async (client) => {
+                const tools = [];
+                let cursor;
+                do {
+                    const page = await client.listTools(cursor ? { cursor } : undefined);
+                    for (const tool of page.tools) {
+                        tools.push({
+                            name: tool.name,
+                            title: tool.title ?? tool.annotations?.title ?? null,
+                            description: tool.description ?? null,
+                            inputSchema: tool.inputSchema,
+                            outputSchema: tool.outputSchema ?? null,
+                            annotations: {
+                                ...(tool.annotations?.title ? { title: tool.annotations.title } : {}),
+                                ...(tool.annotations?.readOnlyHint !== undefined
+                                    ? { readOnlyHint: tool.annotations.readOnlyHint }
+                                    : {}),
+                                ...(tool.annotations?.destructiveHint !== undefined
+                                    ? { destructiveHint: tool.annotations.destructiveHint }
+                                    : {}),
+                                ...(tool.annotations?.idempotentHint !== undefined
+                                    ? { idempotentHint: tool.annotations.idempotentHint }
+                                    : {}),
+                                ...(tool.annotations?.openWorldHint !== undefined
+                                    ? { openWorldHint: tool.annotations.openWorldHint }
+                                    : {}),
+                            },
+                        });
+                        if (tools.length > 1_000)
+                            return tools;
+                    }
+                    cursor = page.nextCursor;
+                } while (cursor);
+                return tools;
+            });
+        },
+        async call(input) {
+            return await connected(input.url, input.accessToken, input.signal, 1_100_000, async (client) => {
+                const result = await client.callTool({
+                    name: input.name,
+                    arguments: input.arguments,
+                });
+                if (!("content" in result)) {
+                    return ToolTestResult.parse({
+                        isError: false,
+                        content: [],
+                        structuredContent: result.toolResult,
+                    });
+                }
+                return ToolTestResult.parse({
+                    isError: result.isError ?? false,
+                    content: result.content,
+                    ...(result.structuredContent !== undefined
+                        ? { structuredContent: result.structuredContent }
+                        : {}),
+                });
+            });
+        },
+    };
+}

package/dist/adapters/semantic-index/semantic-index.d.ts

@@ -0,0 +1,2 @@
+import type { SemanticIndex, SemanticIndexDeps } from "./semantic-index.types.js";
+export declare function createSemanticIndex(deps: SemanticIndexDeps): SemanticIndex;

package/dist/adapters/semantic-index/semantic-index.js

@@ -0,0 +1,57 @@
+const defaultModel = "@cf/baai/bge-m3";
+const maxEmbeddingCharacters = 24_000;
+function embedding(result) {
+    if (typeof result !== "object" ||
+        result === null ||
+        !("data" in result) ||
+        !Array.isArray(result.data) ||
+        !Array.isArray(result.data[0]) ||
+        !result.data[0].every((value) => typeof value === "number")) {
+        throw new Error("The embedding provider returned an invalid response");
+    }
+    return result.data[0];
+}
+function matches(result) {
+    if (typeof result !== "object" ||
+        result === null ||
+        !("matches" in result) ||
+        !Array.isArray(result.matches)) {
+        throw new Error("The semantic index returned an invalid response");
+    }
+    return result.matches.flatMap((match) => {
+        if (typeof match !== "object" ||
+            match === null ||
+            !("id" in match) ||
+            typeof match.id !== "string" ||
+            !("score" in match) ||
+            typeof match.score !== "number") {
+            return [];
+        }
+        return [{ nodeId: match.id, score: Math.max(0, Math.min(1, match.score)) }];
+    });
+}
+export function createSemanticIndex(deps) {
+    const model = deps.model ?? defaultModel;
+    async function embed(text) {
+        return embedding(await deps.ai.run(model, { text: [text] }));
+    }
+    return {
+        async replace(target, content) {
+            const text = `${target.title}\n\n${content}`.slice(0, maxEmbeddingCharacters);
+            await deps.index.upsert([
+                {
+                    id: target.nodeId,
+                    values: await embed(text),
+                    metadata: { versionId: target.versionId },
+                },
+            ]);
+        },
+        async search(query, limit) {
+            const result = await deps.index.query(await embed(query), {
+                topK: Math.max(1, Math.min(100, limit)),
+                returnMetadata: "none",
+            });
+            return matches(result);
+        },
+    };
+}

package/dist/adapters/semantic-index/semantic-index.types.d.ts

@@ -0,0 +1,32 @@
+import type { KnowledgeIndexTarget } from "../../knowledge/knowledge.types.js";
+export interface WorkersAiBinding {
+    run(model: string, input: {
+        text: string[];
+    }): Promise<unknown>;
+}
+export interface VectorizeBinding {
+    upsert(vectors: Array<{
+        id: string;
+        values: number[];
+        metadata: {
+            versionId: string;
+        };
+    }>): Promise<unknown>;
+    query(vector: number[], options: {
+        topK: number;
+        returnMetadata: "none";
+    }): Promise<unknown>;
+}
+export interface SemanticHit {
+    nodeId: string;
+    score: number;
+}
+export interface SemanticIndex {
+    replace(target: KnowledgeIndexTarget, content: string): Promise<void>;
+    search(query: string, limit: number): Promise<SemanticHit[]>;
+}
+export interface SemanticIndexDeps {
+    ai: WorkersAiBinding;
+    index: VectorizeBinding;
+    model?: string;
+}

package/dist/adapters/semantic-index/semantic-index.types.js

@@ -0,0 +1 @@
+export {};

package/dist/adapters/session-cookie/session-cookie.d.ts

@@ -0,0 +1,5 @@
+import type { SessionCodec } from "../../auth/auth.types.js";
+export declare function createSessionCodec(deps: {
+    secret: string;
+    crypto: Crypto;
+}): SessionCodec;