@zackbart/connecta 0.28.0 → 0.29.0

package/dist/config.d.ts

@@ -0,0 +1,631 @@
+import type { ConnectorGrant } from "./connector-access.js";
+import type { CredentialVault } from "./credential-contract.js";
+import { type ConfigInput, type ConfigOutput } from "./config-schema.js";
+import type { AccessTokensModule, ActivityModule, OperatorSurface } from "./module-contracts.js";
+import type { AuthenticatedIdentity, Connector, Executor, IdentityReference, InboundAuth, KVStorage, Logger } from "./types.js";
+/** Config-owned identity rules for one deployment and tenant. */
+export type ConnectorPermission = "all" | "none" | readonly string[];
+declare const discovery: {
+    /**
+     * Maximum connector catalogs/status probes fetched at once by discovery
+     * operations. Default 4.
+     */
+    concurrency: import("./config-schema.js").Field<number, number, true>;
+    /** Fallback tool-list TTL when the downstream omits ttlMs. Default 300 seconds. */
+    catalogTtlSeconds: import("./config-schema.js").Field<number, number, true>;
+    /** Floor for positive downstream hints. Zero hints always disable reuse. Default 0. */
+    catalogMinTtlSeconds: import("./config-schema.js").Field<number, number, true>;
+    /** Ceiling for downstream hints and the fallback, capped by the SDK at 24h. Default 86400. */
+    catalogMaxTtlSeconds: import("./config-schema.js").Field<number, number, true>;
+    /**
+     * Deadline (ms) for each downstream probe/catalog call fanned out by
+     * `search_tools` and by `connecta.search`/`connecta.describe` inside
+     * `execute_code`. Defaults to 30_000. A timed-out connector degrades
+     * independently; this does not apply to tool calls. Catalog walks receive the
+     * same cancellation signal, which aborts an in-flight page where supported and
+     * prevents another from starting.
+     */
+    probeTimeoutMs: import("./config-schema.js").Field<number, number, true>;
+};
+declare const calls: {
+    /**
+     * Deadline (ms) for `call_tool`/`call_destructive_tool` calls that pass no
+     * `timeoutMs`. An explicit per-call value wins. Opt-in: unset by default, so
+     * existing long-running calls gain no surprise deadline.
+     *
+     * Each call makes one attempt. `execute_code` host calls are
+     * unaffected because they already carry their own bound.
+     */
+    defaultTimeoutMs: import("./config-schema.js").Field<number, number | undefined, true>;
+    /**
+     * Max inline result size (bytes) before truncation and `connecta.result` paging.
+     * A positive whole number; default 24_000. Connectors may override it
+     * individually.
+     */
+    maxResultBytes: import("./config-schema.js").Field<number, number, true>;
+};
+declare const results: {
+    /** Stored bytes, including the paging envelope. Default 8 MiB. Zero disables stashing. */
+    maxStashBytes: import("./config-schema.js").Field<number, number, true>;
+    /** Stored or in-flight entries. Default 64. Zero disables stashing. */
+    maxStashEntries: import("./config-schema.js").Field<number, number, true>;
+};
+declare const execute: {
+    /**
+     * Aggregate serialized bytes `connecta.emit` accepts per run. Default
+     * 4_000_000 — a transport bound, not a context bound: emitted image/audio
+     * blocks reach the model as media, not base64 text.
+     */
+    maxEmittedBytes: import("./config-schema.js").Field<number, number, true>;
+    /** Content blocks `connecta.emit` accepts per run. Default 32. */
+    maxEmittedBlocks: import("./config-schema.js").Field<number, number, true>;
+    /** Host calls one program may make. Default 20. */
+    maxHostCalls: import("./config-schema.js").Field<number, number, true>;
+    /**
+     * Deadline for each host call a program makes, in milliseconds. Default
+     * 15_000. Raise it for providers whose legitimate calls run longer, such as
+     * analytics queries; `call_tool`'s own `timeoutMs` is unaffected.
+     */
+    hostCallTimeoutMs: import("./config-schema.js").Field<number, number, true>;
+    /**
+     * Hard ceiling on one execution, in milliseconds, enforced outside the
+     * sandbox. Default 120_000, above both executors' own deadlines (QuickJS
+     * 30_000, the Dynamic Worker 60_000), so it only ends a run whose executor
+     * never settled; that run fails as unresponsive and its admission slot is
+     * released. Keep it above any raised executor deadline.
+     */
+    watchdogMs: import("./config-schema.js").Field<number, number, true>;
+    /**
+     * Trusted-pool writes one program may send, on top of the host-call
+     * budget every call already spends. Default 10.
+     */
+    maxWrites: import("./config-schema.js").Field<number, number, true>;
+};
+declare const codeAdmission: {
+    /** Simultaneous work admitted to this pool. */
+    concurrency: import("./config-schema.js").Field<number, number, true>;
+    /** Callers allowed to wait behind active work. Set zero to fail fast. */
+    maxQueueSize: import("./config-schema.js").Field<number, number, true>;
+    /** Maximum queue wait in milliseconds. */
+    queueTimeoutMs: import("./config-schema.js").Field<number, number, true>;
+    /** Retry hint returned with overload failures, in milliseconds. */
+    retryAfterMs: import("./config-schema.js").Field<number, number, true>;
+};
+declare const requestAdmission: {
+    /** Hard lifetime of an admitted /mcp request. Default 300,000 ms. */
+    maxDurationMs: import("./config-schema.js").Field<number, number, true>;
+    /** Simultaneous work admitted to this pool. */
+    concurrency: import("./config-schema.js").Field<number, number, true>;
+    /** Callers allowed to wait behind active work. Set zero to fail fast. */
+    maxQueueSize: import("./config-schema.js").Field<number, number, true>;
+    /** Maximum queue wait in milliseconds. */
+    queueTimeoutMs: import("./config-schema.js").Field<number, number, true>;
+    /** Retry hint returned with overload failures, in milliseconds. */
+    retryAfterMs: import("./config-schema.js").Field<number, number, true>;
+};
+declare const admission: {
+    /**
+     * The `/mcp` request boundary. Defaults to 16 active, 32 queued, and a
+     * 5-second maximum wait.
+     */
+    requests: import("./config-schema.js").Field<{
+        maxDurationMs?: number | undefined;
+        concurrency?: number | undefined;
+        maxQueueSize?: number | undefined;
+        queueTimeoutMs?: number | undefined;
+        retryAfterMs?: number | undefined;
+    }, {
+        readonly maxDurationMs: number;
+        readonly concurrency: number;
+        readonly maxQueueSize: number;
+        readonly queueTimeoutMs: number;
+        readonly retryAfterMs: number;
+    }, true> & {
+        readonly shape: {
+            /** Hard lifetime of an admitted /mcp request. Default 300,000 ms. */
+            maxDurationMs: import("./config-schema.js").Field<number, number, true>;
+            /** Simultaneous work admitted to this pool. */
+            concurrency: import("./config-schema.js").Field<number, number, true>;
+            /** Callers allowed to wait behind active work. Set zero to fail fast. */
+            maxQueueSize: import("./config-schema.js").Field<number, number, true>;
+            /** Maximum queue wait in milliseconds. */
+            queueTimeoutMs: import("./config-schema.js").Field<number, number, true>;
+            /** Retry hint returned with overload failures, in milliseconds. */
+            retryAfterMs: import("./config-schema.js").Field<number, number, true>;
+        };
+    };
+    /**
+     * Fallback pool for an `executor` that does not implement its own `acquire`.
+     * Defaults to 2 active, 8 queued, and a 5-second maximum wait. Bounded
+     * executors (including `quickJsExecutor`) keep their own tighter pool.
+     */
+    code: import("./config-schema.js").Field<{
+        concurrency?: number | undefined;
+        maxQueueSize?: number | undefined;
+        queueTimeoutMs?: number | undefined;
+        retryAfterMs?: number | undefined;
+    }, {
+        readonly concurrency: number;
+        readonly maxQueueSize: number;
+        readonly queueTimeoutMs: number;
+        readonly retryAfterMs: number;
+    }, true> & {
+        readonly shape: {
+            /** Simultaneous work admitted to this pool. */
+            concurrency: import("./config-schema.js").Field<number, number, true>;
+            /** Callers allowed to wait behind active work. Set zero to fail fast. */
+            maxQueueSize: import("./config-schema.js").Field<number, number, true>;
+            /** Maximum queue wait in milliseconds. */
+            queueTimeoutMs: import("./config-schema.js").Field<number, number, true>;
+            /** Retry hint returned with overload failures, in milliseconds. */
+            retryAfterMs: import("./config-schema.js").Field<number, number, true>;
+        };
+    };
+};
+declare const identity: {
+    /**
+     * What this admitted identity may discover and call: `"all"`, or a list
+     * whose entries are connector ids (the whole connector) and `connector.tool`
+     * addresses (that tool only), or `{ tool: "connector.tool",
+     * requireReadOnly: true }` for an exact tool only while its loaded catalog
+     * explicitly classifies it read-only. Grants are additive: an unrestricted
+     * connector or address grant wins over the guarded form. An address naming
+     * a tool the catalog lacks is unreachable and warned once, never widened.
+     */
+    connectorAccess: import("./config-schema.js").Field<(identity: Readonly<AuthenticatedIdentity>) => "all" | readonly ConnectorGrant[] | Promise<"all" | readonly ConnectorGrant[]>, ((identity: Readonly<AuthenticatedIdentity>) => "all" | readonly ConnectorGrant[] | Promise<"all" | readonly ConnectorGrant[]>) | undefined, true>;
+    /** Global payload-free activity reads. Defaults to interactive humans. */
+    activityAccess: import("./config-schema.js").Field<(principal: Readonly<IdentityReference>) => boolean | Promise<boolean>, ((principal: Readonly<IdentityReference>) => boolean | Promise<boolean>) | undefined, true>;
+    /** Shared credential and OAuth administration. Defaults to none. */
+    credentialAdministration: import("./config-schema.js").Field<(identity: Readonly<AuthenticatedIdentity>) => ConnectorPermission | Promise<ConnectorPermission>, ((identity: Readonly<AuthenticatedIdentity>) => ConnectorPermission | Promise<ConnectorPermission>) | undefined, true>;
+    /** Client-token lifecycle management by interactive humans. Defaults to false. */
+    accessTokenManagement: import("./config-schema.js").Field<(identity: Readonly<AuthenticatedIdentity>) => boolean | Promise<boolean>, ((identity: Readonly<AuthenticatedIdentity>) => boolean | Promise<boolean>) | undefined, true>;
+    /** Connecting or changing the caller's personal account. Defaults to none. */
+    personalConnection: import("./config-schema.js").Field<(identity: Readonly<AuthenticatedIdentity>) => ConnectorPermission | Promise<ConnectorPermission>, ((identity: Readonly<AuthenticatedIdentity>) => ConnectorPermission | Promise<ConnectorPermission>) | undefined, true>;
+};
+declare const pool: {
+    /** Programs may write only in trusted pools. Default read-only. */
+    trust: import("./config-schema.js").Field<"trusted" | "read-only", "trusted" | "read-only", true>;
+    /** Connector ids and exact `connector.tool` addresses in this pool. */
+    tools: import("./config-schema.js").Field<readonly string[], readonly string[], false>;
+    /**
+     * Whether this admitted identity may open the pool. Denied by default:
+     * a pool with no grant serves nobody. A false return, a throw, and an
+     * undeclared pool name are the same 404.
+     */
+    grant: import("./config-schema.js").Field<(identity: Readonly<AuthenticatedIdentity>) => boolean | Promise<boolean>, ((identity: Readonly<AuthenticatedIdentity>) => boolean | Promise<boolean>) | undefined, true>;
+};
+declare const connectaConfig: {
+    connectors: import("./config-schema.js").Field<Connector[], readonly Connector[], false>;
+    /** Inbound auth adapters, such as clerkAuth(...); omit for open (dev). */
+    auth: import("./config-schema.js").Field<InboundAuth | InboundAuth[], readonly InboundAuth[], true>;
+    /** Code-derived connection visibility and independent management permissions. */
+    identity: import("./config-schema.js").Field<{
+        connectorAccess?: ((identity: Readonly<AuthenticatedIdentity>) => "all" | readonly ConnectorGrant[] | Promise<"all" | readonly ConnectorGrant[]>) | undefined;
+        activityAccess?: ((principal: Readonly<IdentityReference>) => boolean | Promise<boolean>) | undefined;
+        credentialAdministration?: ((identity: Readonly<AuthenticatedIdentity>) => ConnectorPermission | Promise<ConnectorPermission>) | undefined;
+        accessTokenManagement?: ((identity: Readonly<AuthenticatedIdentity>) => boolean | Promise<boolean>) | undefined;
+        personalConnection?: ((identity: Readonly<AuthenticatedIdentity>) => ConnectorPermission | Promise<ConnectorPermission>) | undefined;
+    }, {
+        readonly connectorAccess: ((identity: Readonly<AuthenticatedIdentity>) => "all" | readonly ConnectorGrant[] | Promise<"all" | readonly ConnectorGrant[]>) | undefined;
+        readonly activityAccess: ((principal: Readonly<IdentityReference>) => boolean | Promise<boolean>) | undefined;
+        readonly credentialAdministration: ((identity: Readonly<AuthenticatedIdentity>) => ConnectorPermission | Promise<ConnectorPermission>) | undefined;
+        readonly accessTokenManagement: ((identity: Readonly<AuthenticatedIdentity>) => boolean | Promise<boolean>) | undefined;
+        readonly personalConnection: ((identity: Readonly<AuthenticatedIdentity>) => ConnectorPermission | Promise<ConnectorPermission>) | undefined;
+    }, true> & {
+        readonly shape: {
+            /**
+             * What this admitted identity may discover and call: `"all"`, or a list
+             * whose entries are connector ids (the whole connector) and `connector.tool`
+             * addresses (that tool only), or `{ tool: "connector.tool",
+             * requireReadOnly: true }` for an exact tool only while its loaded catalog
+             * explicitly classifies it read-only. Grants are additive: an unrestricted
+             * connector or address grant wins over the guarded form. An address naming
+             * a tool the catalog lacks is unreachable and warned once, never widened.
+             */
+            connectorAccess: import("./config-schema.js").Field<(identity: Readonly<AuthenticatedIdentity>) => "all" | readonly ConnectorGrant[] | Promise<"all" | readonly ConnectorGrant[]>, ((identity: Readonly<AuthenticatedIdentity>) => "all" | readonly ConnectorGrant[] | Promise<"all" | readonly ConnectorGrant[]>) | undefined, true>;
+            /** Global payload-free activity reads. Defaults to interactive humans. */
+            activityAccess: import("./config-schema.js").Field<(principal: Readonly<IdentityReference>) => boolean | Promise<boolean>, ((principal: Readonly<IdentityReference>) => boolean | Promise<boolean>) | undefined, true>;
+            /** Shared credential and OAuth administration. Defaults to none. */
+            credentialAdministration: import("./config-schema.js").Field<(identity: Readonly<AuthenticatedIdentity>) => ConnectorPermission | Promise<ConnectorPermission>, ((identity: Readonly<AuthenticatedIdentity>) => ConnectorPermission | Promise<ConnectorPermission>) | undefined, true>;
+            /** Client-token lifecycle management by interactive humans. Defaults to false. */
+            accessTokenManagement: import("./config-schema.js").Field<(identity: Readonly<AuthenticatedIdentity>) => boolean | Promise<boolean>, ((identity: Readonly<AuthenticatedIdentity>) => boolean | Promise<boolean>) | undefined, true>;
+            /** Connecting or changing the caller's personal account. Defaults to none. */
+            personalConnection: import("./config-schema.js").Field<(identity: Readonly<AuthenticatedIdentity>) => ConnectorPermission | Promise<ConnectorPermission>, ((identity: Readonly<AuthenticatedIdentity>) => ConnectorPermission | Promise<ConnectorPermission>) | undefined, true>;
+        };
+    };
+    /** Named tool pools, each served at `/mcp/<name>` to identities its grant admits. */
+    pools: import("./config-schema.js").Field<Record<string, {
+        trust?: "trusted" | "read-only" | undefined;
+        grant?: ((identity: Readonly<AuthenticatedIdentity>) => boolean | Promise<boolean>) | undefined;
+        tools: readonly string[];
+    }>, Readonly<Record<string, {
+        readonly trust: "trusted" | "read-only";
+        readonly tools: readonly string[];
+        readonly grant: ((identity: Readonly<AuthenticatedIdentity>) => boolean | Promise<boolean>) | undefined;
+    }>> | undefined, true>;
+    /** Trust of the default /mcp endpoint. Default read-only. */
+    trust: import("./config-schema.js").Field<"trusted" | "read-only", "trusted" | "read-only", true>;
+    /** Exact connector id -> tool name -> verdict. Unknown names fail at catalog publication. */
+    classification: import("./config-schema.js").Field<Record<string, Record<string, "read" | "write">>, Readonly<Record<string, Readonly<Record<string, "read" | "write">>>> | undefined, true>;
+    /**
+     * The deployment's one store: `d1Storage(env.CONNECTA_DB)` from
+     * `@zackbart/connecta/d1` on Workers, `sqliteStorage(path)` from
+     * `@zackbart/connecta/sqlite` on Node. Defaults to memoryStorage(), which
+     * forgets everything on restart.
+     */
+    storage: import("./config-schema.js").Field<KVStorage, KVStorage, true>;
+    /**
+     * Public base URL. Defaults to the request origin per-request. Configuring an
+     * HTTPS URL also redirects matching inbound HTTP requests to HTTPS.
+     */
+    publicUrl: import("./config-schema.js").Field<string, string | undefined, true>;
+    /**
+     * Exact browser MCP origins, or "*". Defaults to publicUrl's origin and
+     * HTTP(S) loopback origins at any port. Originless clients are admitted.
+     */
+    allowedOrigins: import("./config-schema.js").Field<readonly string[] | "*", readonly string[] | "*" | undefined, true>;
+    /** Optional recorder and reader, created by activityHistory() from /activity. */
+    activity: import("./config-schema.js").Field<ActivityModule, ActivityModule | undefined, true>;
+    /** Replaceable owner-partitioned credential storage. Omit for config-owned secrets. */
+    vault: import("./config-schema.js").Field<CredentialVault, CredentialVault | undefined, true>;
+    /** Optional connection UI, created by operatorUi() from /ui. */
+    ui: import("./config-schema.js").Field<OperatorSurface, OperatorSurface | undefined, true>;
+    /** Optional managed client tokens, created by accessTokens() from /auth/access-tokens. */
+    accessTokens: import("./config-schema.js").Field<AccessTokensModule, AccessTokensModule | undefined, true>;
+    /** Tool-catalog TTL bounds and probe deadlines. */
+    discovery: import("./config-schema.js").Field<{
+        concurrency?: number | undefined;
+        catalogTtlSeconds?: number | undefined;
+        catalogMinTtlSeconds?: number | undefined;
+        catalogMaxTtlSeconds?: number | undefined;
+        probeTimeoutMs?: number | undefined;
+    }, {
+        readonly concurrency: number;
+        readonly catalogTtlSeconds: number;
+        readonly catalogMinTtlSeconds: number;
+        readonly catalogMaxTtlSeconds: number;
+        readonly probeTimeoutMs: number;
+    }, true> & {
+        readonly shape: {
+            /**
+             * Maximum connector catalogs/status probes fetched at once by discovery
+             * operations. Default 4.
+             */
+            concurrency: import("./config-schema.js").Field<number, number, true>;
+            /** Fallback tool-list TTL when the downstream omits ttlMs. Default 300 seconds. */
+            catalogTtlSeconds: import("./config-schema.js").Field<number, number, true>;
+            /** Floor for positive downstream hints. Zero hints always disable reuse. Default 0. */
+            catalogMinTtlSeconds: import("./config-schema.js").Field<number, number, true>;
+            /** Ceiling for downstream hints and the fallback, capped by the SDK at 24h. Default 86400. */
+            catalogMaxTtlSeconds: import("./config-schema.js").Field<number, number, true>;
+            /**
+             * Deadline (ms) for each downstream probe/catalog call fanned out by
+             * `search_tools` and by `connecta.search`/`connecta.describe` inside
+             * `execute_code`. Defaults to 30_000. A timed-out connector degrades
+             * independently; this does not apply to tool calls. Catalog walks receive the
+             * same cancellation signal, which aborts an in-flight page where supported and
+             * prevents another from starting.
+             */
+            probeTimeoutMs: import("./config-schema.js").Field<number, number, true>;
+        };
+    };
+    /** Deployment-wide call deadlines and result paging threshold. */
+    calls: import("./config-schema.js").Field<{
+        defaultTimeoutMs?: number | undefined;
+        maxResultBytes?: number | undefined;
+    }, {
+        readonly defaultTimeoutMs: number | undefined;
+        readonly maxResultBytes: number;
+    }, true> & {
+        readonly shape: {
+            /**
+             * Deadline (ms) for `call_tool`/`call_destructive_tool` calls that pass no
+             * `timeoutMs`. An explicit per-call value wins. Opt-in: unset by default, so
+             * existing long-running calls gain no surprise deadline.
+             *
+             * Each call makes one attempt. `execute_code` host calls are
+             * unaffected because they already carry their own bound.
+             */
+            defaultTimeoutMs: import("./config-schema.js").Field<number, number | undefined, true>;
+            /**
+             * Max inline result size (bytes) before truncation and `connecta.result` paging.
+             * A positive whole number; default 24_000. Connectors may override it
+             * individually.
+             */
+            maxResultBytes: import("./config-schema.js").Field<number, number, true>;
+        };
+    };
+    /** Runtime-wide transient result stash limits, shared across subjects. */
+    results: import("./config-schema.js").Field<{
+        maxStashBytes?: number | undefined;
+        maxStashEntries?: number | undefined;
+    }, {
+        readonly maxStashBytes: number;
+        readonly maxStashEntries: number;
+    }, true> & {
+        readonly shape: {
+            /** Stored bytes, including the paging envelope. Default 8 MiB. Zero disables stashing. */
+            maxStashBytes: import("./config-schema.js").Field<number, number, true>;
+            /** Stored or in-flight entries. Default 64. Zero disables stashing. */
+            maxStashEntries: import("./config-schema.js").Field<number, number, true>;
+        };
+    };
+    /** Budgets for execute_code programs: host calls, writes, and `connecta.emit`. */
+    execute: import("./config-schema.js").Field<{
+        maxEmittedBytes?: number | undefined;
+        maxEmittedBlocks?: number | undefined;
+        maxHostCalls?: number | undefined;
+        hostCallTimeoutMs?: number | undefined;
+        watchdogMs?: number | undefined;
+        maxWrites?: number | undefined;
+    }, {
+        readonly maxEmittedBytes: number;
+        readonly maxEmittedBlocks: number;
+        readonly maxHostCalls: number;
+        readonly hostCallTimeoutMs: number;
+        readonly watchdogMs: number;
+        readonly maxWrites: number;
+    }, true> & {
+        readonly shape: {
+            /**
+             * Aggregate serialized bytes `connecta.emit` accepts per run. Default
+             * 4_000_000 — a transport bound, not a context bound: emitted image/audio
+             * blocks reach the model as media, not base64 text.
+             */
+            maxEmittedBytes: import("./config-schema.js").Field<number, number, true>;
+            /** Content blocks `connecta.emit` accepts per run. Default 32. */
+            maxEmittedBlocks: import("./config-schema.js").Field<number, number, true>;
+            /** Host calls one program may make. Default 20. */
+            maxHostCalls: import("./config-schema.js").Field<number, number, true>;
+            /**
+             * Deadline for each host call a program makes, in milliseconds. Default
+             * 15_000. Raise it for providers whose legitimate calls run longer, such as
+             * analytics queries; `call_tool`'s own `timeoutMs` is unaffected.
+             */
+            hostCallTimeoutMs: import("./config-schema.js").Field<number, number, true>;
+            /**
+             * Hard ceiling on one execution, in milliseconds, enforced outside the
+             * sandbox. Default 120_000, above both executors' own deadlines (QuickJS
+             * 30_000, the Dynamic Worker 60_000), so it only ends a run whose executor
+             * never settled; that run fails as unresponsive and its admission slot is
+             * released. Keep it above any raised executor deadline.
+             */
+            watchdogMs: import("./config-schema.js").Field<number, number, true>;
+            /**
+             * Trusted-pool writes one program may send, on top of the host-call
+             * budget every call already spends. Default 10.
+             */
+            maxWrites: import("./config-schema.js").Field<number, number, true>;
+        };
+    };
+    /**
+     * Runtime-portable server-memory boundaries. `/health` and operator routes
+     * do not consume these permits, so they remain responsive during MCP
+     * saturation.
+     */
+    admission: import("./config-schema.js").Field<{
+        requests?: {
+            maxDurationMs?: number | undefined;
+            concurrency?: number | undefined;
+            maxQueueSize?: number | undefined;
+            queueTimeoutMs?: number | undefined;
+            retryAfterMs?: number | undefined;
+        } | undefined;
+        code?: {
+            concurrency?: number | undefined;
+            maxQueueSize?: number | undefined;
+            queueTimeoutMs?: number | undefined;
+            retryAfterMs?: number | undefined;
+        } | undefined;
+    }, {
+        readonly requests: {
+            readonly maxDurationMs: number;
+            readonly concurrency: number;
+            readonly maxQueueSize: number;
+            readonly queueTimeoutMs: number;
+            readonly retryAfterMs: number;
+        };
+        readonly code: {
+            readonly concurrency: number;
+            readonly maxQueueSize: number;
+            readonly queueTimeoutMs: number;
+            readonly retryAfterMs: number;
+        };
+    }, true> & {
+        readonly shape: {
+            /**
+             * The `/mcp` request boundary. Defaults to 16 active, 32 queued, and a
+             * 5-second maximum wait.
+             */
+            requests: import("./config-schema.js").Field<{
+                maxDurationMs?: number | undefined;
+                concurrency?: number | undefined;
+                maxQueueSize?: number | undefined;
+                queueTimeoutMs?: number | undefined;
+                retryAfterMs?: number | undefined;
+            }, {
+                readonly maxDurationMs: number;
+                readonly concurrency: number;
+                readonly maxQueueSize: number;
+                readonly queueTimeoutMs: number;
+                readonly retryAfterMs: number;
+            }, true> & {
+                readonly shape: {
+                    /** Hard lifetime of an admitted /mcp request. Default 300,000 ms. */
+                    maxDurationMs: import("./config-schema.js").Field<number, number, true>;
+                    /** Simultaneous work admitted to this pool. */
+                    concurrency: import("./config-schema.js").Field<number, number, true>;
+                    /** Callers allowed to wait behind active work. Set zero to fail fast. */
+                    maxQueueSize: import("./config-schema.js").Field<number, number, true>;
+                    /** Maximum queue wait in milliseconds. */
+                    queueTimeoutMs: import("./config-schema.js").Field<number, number, true>;
+                    /** Retry hint returned with overload failures, in milliseconds. */
+                    retryAfterMs: import("./config-schema.js").Field<number, number, true>;
+                };
+            };
+            /**
+             * Fallback pool for an `executor` that does not implement its own `acquire`.
+             * Defaults to 2 active, 8 queued, and a 5-second maximum wait. Bounded
+             * executors (including `quickJsExecutor`) keep their own tighter pool.
+             */
+            code: import("./config-schema.js").Field<{
+                concurrency?: number | undefined;
+                maxQueueSize?: number | undefined;
+                queueTimeoutMs?: number | undefined;
+                retryAfterMs?: number | undefined;
+            }, {
+                readonly concurrency: number;
+                readonly maxQueueSize: number;
+                readonly queueTimeoutMs: number;
+                readonly retryAfterMs: number;
+            }, true> & {
+                readonly shape: {
+                    /** Simultaneous work admitted to this pool. */
+                    concurrency: import("./config-schema.js").Field<number, number, true>;
+                    /** Callers allowed to wait behind active work. Set zero to fail fast. */
+                    maxQueueSize: import("./config-schema.js").Field<number, number, true>;
+                    /** Maximum queue wait in milliseconds. */
+                    queueTimeoutMs: import("./config-schema.js").Field<number, number, true>;
+                    /** Retry hint returned with overload failures, in milliseconds. */
+                    retryAfterMs: import("./config-schema.js").Field<number, number, true>;
+                };
+            };
+        };
+    };
+    /** Diagnostic output. Use "silent" to disable all diagnostic logging. */
+    logger: import("./config-schema.js").Field<Logger | "silent", Logger, true>;
+    serverInfo: import("./config-schema.js").Field<{
+        name?: string | undefined;
+        version?: string | undefined;
+        title?: string | undefined;
+        websiteUrl?: string | undefined;
+        icons?: {
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            src: string;
+        }[] | undefined;
+    }, {
+        readonly name: string | undefined;
+        readonly version: string | undefined;
+        readonly title: string | undefined;
+        readonly websiteUrl: string | undefined;
+        readonly icons: readonly {
+            readonly src: string;
+            readonly mimeType: string | undefined;
+            readonly sizes: readonly string[] | undefined;
+        }[] | undefined;
+    }, true> & {
+        readonly shape: {
+            name: import("./config-schema.js").Field<string, string | undefined, true>;
+            version: import("./config-schema.js").Field<string, string | undefined, true>;
+            /** Human-readable name clients may show instead of `name`. */
+            title: import("./config-schema.js").Field<string, string | undefined, true>;
+            /** Homepage clients may link from the server listing: an absolute http(s) URL. */
+            websiteUrl: import("./config-schema.js").Field<string, string | undefined, true>;
+            /** MCP icons-spec entries; clients render these instead of a scraped favicon. */
+            icons: import("./config-schema.js").Field<{
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                src: string;
+            }[], readonly {
+                readonly src: string;
+                readonly mimeType: string | undefined;
+                readonly sizes: readonly string[] | undefined;
+            }[] | undefined, true>;
+        };
+    };
+    /** Deployment metadata exposed by /health (for example a Worker version). */
+    deploymentInfo: import("./config-schema.js").Field<Record<string, unknown>, Record<string, unknown> | undefined, true>;
+    /**
+     * Required sandbox for `execute_code`. Workers use
+     * `workerExecutor({ loader: env.LOADER })` from
+     * `@zackbart/connecta/worker`; Node uses `quickJsExecutor()` from
+     * `@zackbart/connecta/quickjs`. Direct upstream DynamicWorkerExecutor
+     * construction throws because its request-owned handles cannot be released.
+     * Custom sandboxes explicitly opt in with
+     * `customExecutor(myExecutor, { lifecycle: "self-managed" })`.
+     */
+    executor: import("./config-schema.js").Field<Executor, Executor, false>;
+};
+/** A deployment's whole configuration, passed to `createConnecta`. */
+export type ConnectaConfig = ConfigInput<typeof connectaConfig>;
+/** Tool-catalog TTL bounds and probe deadlines. */
+export type ConnectaDiscoveryConfig = ConfigInput<typeof discovery>;
+/** Deployment-wide call deadlines and inline-result paging thresholds. */
+export type ConnectaCallsConfig = ConfigInput<typeof calls>;
+/** Runtime-wide bounds for transient direct-call result paging. */
+export type ConnectaResultsConfig = ConfigInput<typeof results>;
+/** Budgets for execute_code programs: host calls and rich output (`connecta.emit`). */
+export type ConnectaExecuteConfig = ConfigInput<typeof execute>;
+export type AdmissionPoolConfig = ConfigInput<typeof codeAdmission>;
+export type RequestAdmissionConfig = ConfigInput<typeof requestAdmission>;
+/** Runtime-portable server-memory boundaries for `/mcp` and fallback code-mode work. */
+export type ConnectaAdmissionConfig = ConfigInput<typeof admission>;
+export type ConnectaIdentityConfig = ConfigInput<typeof identity>;
+/**
+ * A named tool pool served at `/mcp/<name>`. The pool is the slice a client
+ * pointed at that endpoint may see; the identity's own `connectorAccess`
+ * remains its ceiling and the pool can only narrow it.
+ */
+export type ConnectaPoolConfig = ConfigInput<typeof pool>;
+type Parsed = ConfigOutput<typeof connectaConfig>;
+/**
+ * The configuration a Connecta runs with: validated, every default applied,
+ * auth ordered, and `serverInfo` named and versioned. Built once by createConnecta; nothing downstream re-derives it.
+ */
+export interface ResolvedConfig extends Omit<Parsed, "serverInfo"> {
+    /** `serverInfo` with its name and version defaults applied. */
+    readonly serverInfo: {
+        readonly name: string;
+        readonly version: string;
+        readonly title?: string;
+        readonly websiteUrl?: string;
+        readonly icons?: Array<{
+            src: string;
+            mimeType?: string;
+            sizes?: string[];
+        }>;
+    };
+}
+/**
+ * Validate a configuration and apply every default. Unknown keys are refused
+ * first, before any value is read, so a typo beside a getter or a secret
+ * neither runs it nor echoes it; then each present value is checked in
+ * schema order and the first mistake throws with its path.
+ */
+export declare function resolveConfig(config: ConnectaConfig): ResolvedConfig;
+/**
+ * {@link resolveConfig}, also returning the plain copy it resolved: the
+ * configuration as read through property descriptors, which is what any later
+ * question about what the deployment set explicitly must read, never the
+ * caller's object, whose getters or Proxy traps must not run.
+ */
+export declare function readConfig(config: ConnectaConfig): {
+    input: ConnectaConfig;
+    resolved: ResolvedConfig;
+};
+/**
+ * Declare a deployment's configuration as a function of its environment:
+ * `process.env` on Node, the Worker's `env` bindings on Workers. Optional
+ * modules are ordinary type-checked expressions —
+ * `vault: env.KEY ? encryptedCredentialVault(storage, env.KEY) : undefined` —
+ * rather than commented blocks, and the entry file stays a few lines: it
+ * imports the default export of its `connecta.config.ts` and calls
+ * `createConnecta(config(process.env))`.
+ *
+ * The factory runs when the entry calls it, never at import, so a Worker can
+ * import it at global scope. Validation still happens in createConnecta.
+ */
+export declare function defineConfig<Env>(factory: (env: Env) => ConnectaConfig): (env: Env) => ConnectaConfig;
+/** The execute_code budgets a runner enforces, read from one resolved config. */
+export declare function executeLimits(config: ResolvedConfig): {
+    discoveryConcurrency: number;
+    probeTimeoutMs: number;
+    maxEmittedBytes: number;
+    maxEmittedBlocks: number;
+    maxHostCalls: number;
+    hostCallTimeoutMs: number;
+    watchdogMs: number;
+    maxWrites: number;
+};
+export {};