@zackbart/connecta 0.34.0 → 0.35.0

package/dist/provider.d.ts

@@ -1,12 +1,6 @@
 import { type Field } from "./config-schema.js";
-import type { Connector, ConnectorCallAdmissionPolicy, ConnectorUsageGuide, ToolClassification } from "./types.js";
-/**
- * How a provider reaches its vendor: the vendor's hosted MCP server, an
- * `api()` connector over the vendor's HTTP API, one connector composing both
- * with an explicit operation ownership map, or `"dual"`: configuration selects the implementation, usually by `auth.type`. Mixpanel
- * uses explicit `via` because service accounts reach both implementations.
- */
-export type ProviderKind = "mcp" | "api" | "composed" | "dual";
+import { type ConnectorCallErrorCode } from "./errors.js";
+import type { Connector, ConnectorCallAdmissionPolicy, ConnectorUsageGuide } from "./types.js";
 /** Options every provider accepts, validated before `create` runs. */
 export interface ProviderOptions {
     /** What this connection is for and which decisions it answers. Required. */
@@ -19,6 +13,8 @@ export interface ProviderOptions {
     authScope?: "shared" | "personal";
     /** Connector-specific inline result limit; omit to inherit the deployment. */
     maxResultBytes?: number;
+    /** Serve only read-classified tools on every endpoint. Defaults to false. */
+    readOnly?: boolean;
     /** Optional per-runtime downstream call-admission policy. */
     callAdmission?: ConnectorCallAdmissionPolicy;
 }
@@ -82,8 +78,11 @@ export declare const CALL_ADMISSION: Omit<Field<unknown, ConnectorCallAdmissionP
     parse(value: unknown, path: string): ConnectorCallAdmissionPolicy;
     readonly shape: typeof admissionPolicy.shape;
 };
+/** Validate the common connector policy before a deployment can serve. */
+export declare const READ_ONLY: Field<boolean, boolean | undefined, true>;
 /** Options every maintained provider shares. */
 export declare const PROVIDER_COMMON: {
+    readOnly: Field<boolean, boolean | undefined, true>;
     callAdmission: Omit<Field<unknown, ConnectorCallAdmissionPolicy | undefined, true>, "parse"> & {
         parse(value: unknown, path: string): ConnectorCallAdmissionPolicy;
         readonly shape: typeof admissionPolicy.shape;
@@ -91,15 +90,18 @@ export declare const PROVIDER_COMMON: {
     instructions: Field<unknown, unknown, true>;
     title: Field<unknown, unknown, true>;
     authScope: Field<unknown, unknown, true>;
-    maxResultBytes: Field<unknown, unknown, true>;
     purpose: Field<unknown, unknown, true>;
+    maxResultBytes: Field<unknown, unknown, true>;
 };
 /** The provider's maintained, connection-independent usage guide. */
 export interface ProviderSkill {
     /**
      * Markdown rendered after the heading and the connection context. It states
      * conventions the vendor's schemas cannot carry, and never varies by
-     * deployment.
+     * deployment. A standard guide (decision 0011, G) is `SKILL.md`'s body
+     * followed by its generated `## Conventions`; text that differs by
+     * implementation or option stands in `<!-- when: <key> -->` …
+     * `<!-- end -->` blocks the definition's `blocks` selects.
      */
     content: string;
     /** Heading for deployment instructions, such as `"Workspace instructions"`. */
@@ -107,6 +109,56 @@ export interface ProviderSkill {
     /** Exact generated guide fragments used by existing renderers. */
     fragments?: Readonly<Record<string, string>>;
 }
+/**
+ * The closed key set of a guide's `<!-- when: <key> -->` blocks and the pure
+ * selector that picks a connection's keys from its options (decision 0011,
+ * G2). Select only the blocks this API configuration uses.
+ */
+export interface ProviderGuideBlocks<O> {
+    readonly keys: readonly string[];
+    /** The keys whose blocks this connection renders, in any order. */
+    select(options: Readonly<O>): readonly string[];
+}
+/**
+ * Facts the provider kit (decision 0010) declares for `providers:generate`:
+ * `drift.json`'s `generated.operations` and the guide's Conventions. Plain
+ * data, never read at runtime. The kit's `defineApiProvider` sets them.
+ */
+export interface ProviderKitFacts {
+    /** `manifest(vendor)`: every operation the provider's tools send, as `"METHOD /path"`. */
+    readonly operations: readonly string[];
+    /** The `limit` default and maximum every paged read declares. */
+    readonly pageSize?: {
+        readonly default: number;
+        readonly max: number;
+    };
+    /** The hatch's tool prefix and its reviewed verdict per `"METHOD /path"`. */
+    readonly hatch?: {
+        readonly name: string;
+        readonly verdicts: Readonly<Record<string, "read" | "write" | "destructive" | "refuse">>;
+        /** Separate-cursor paging opts into the generated hatch paging convention. */
+        readonly paging?: "argument" | "parameter";
+        readonly fieldsRoot?: string;
+    };
+    /**
+     * The vendor's declared error meanings, for the Errors convention: the code
+     * an unknown id fails with, whether it proves absence, and each documented
+     * conflict source.
+     */
+    readonly errors?: {
+        readonly unknownId: ConnectorCallErrorCode;
+        readonly provesAbsence: boolean;
+        readonly conflicts: readonly string[];
+    };
+    /** Whether a write takes an idempotency key the vendor honors, checked against the built tools. */
+    readonly idempotencyKey?: boolean;
+    /**
+     * Set only when the hatch refuses a write carrying a withheld placeholder
+     * value; the Withheld values convention promises exactly that. The kit sets
+     * it for its standard hatch; kit write builders refuse the same markers.
+     */
+    readonly refusesWithheld?: true;
+}
 /** Connection facts a provider renders around its maintained guide. */
 export interface ProviderGuideInput {
     /**
@@ -123,13 +175,11 @@ export interface ProviderGuideInput {
 }
 /** What `defineProvider()` hands `create` after validating its options. */
 export interface ProviderContext {
-    /** The definition's reviewed classification, for `remoteMcp({ classify })`. */
-    readonly classify?: ToolClassification;
     /**
      * Common connector options the deployment set, and only those, ready to
      * spread into `remoteMcp()` or `api()` options.
      */
-    readonly connectorOptions: Readonly<Pick<ProviderOptions, "authScope" | "maxResultBytes" | "callAdmission">>;
+    readonly connectorOptions: Readonly<Pick<ProviderOptions, "authScope" | "maxResultBytes" | "callAdmission" | "readOnly">>;
     /**
      * Render the maintained skill with this connection's context and the
      * deployment's instructions. Instructions are appended; they never replace
@@ -145,26 +195,23 @@ export interface ProviderDefinition<O extends ProviderOptions> {
     name: string;
     /** Vendor display name, and the default guide heading. */
     title: string;
-    kind: ProviderKind;
+    kind: "api";
     skill: ProviderSkill;
     /** Maintained display name in the generated README inventory. */
     readme?: string;
-    /** Reviewed build facts; generation never raises an observed cap. */
+    /** Reviewed build facts: the bundle report's baseline, never a cap. */
     bundle?: {
         baselineGzip: number;
-        maxGzip: number;
+        /** @deprecated Ignored: provider entries are reported, not capped. */
+        maxGzip?: number;
         note?: string;
     };
     /** Closed factory options, declared with `optionsOf<O>()` for key parity. */
     options: Field<unknown, unknown>;
-    /**
-     * Reviewed classification of the vendor's hosted MCP catalog. Hosted,
-     * composed, and dual providers pass it to `remoteMcp({ classify })` through
-     * `ProviderContext.classify`, so the verdicts that classify live tools and
-     * the record a drift check reads cannot disagree. `api()` providers annotate
-     * each tool they author and must omit it.
-     */
-    classify?: ToolClassification;
+    /** Required when the guide holds `<!-- when: <key> -->` blocks. */
+    blocks?: ProviderGuideBlocks<O>;
+    /** Set by the provider kit; see `ProviderKitFacts`. */
+    kit?: ProviderKitFacts;
     /**
      * Build the connector. Runs synchronously at construction after its closed
      * options and common values are validated. Throw here for provider-specific
@@ -185,12 +232,4 @@ export interface ProviderFactory<O extends ProviderOptions> {
  * so a deployment never boots in the wrong shape (INV-11).
  */
 export declare function defineProvider<O extends ProviderOptions>(definition: ProviderDefinition<O>): ProviderFactory<O>;
-/**
- * Attach the same validated definition to an existing provider constructor.
- * Its option policy stays in its builder during the mechanical folder move;
- * adopting defineProvider's common-value policy is a separate conversion.
- */
-export declare function asProviderFactory<O extends ProviderOptions>(definition: Omit<ProviderDefinition<O>, "create"> & {
-    create(id: string, options: Readonly<O>): Connector;
-}): ProviderFactory<O>;
 export {};

package/dist/provider.js

@@ -1,10 +1,7 @@
-// The one shape every maintained provider takes. Deliberately transport-free:
-// it imports neither `remoteMcp()` nor `api()`, so an `api()` provider does not
-// acquire the MCP client, OAuth, or Effect graph by using it, and a hosted
-// provider does not acquire `api()`. Its runtime imports validate plain
-// options and reviewed classification, with no I/O.
+// Transport-free maintained API provider definitions and construction validation.
 import { array, assertKnownOptions, ConfigError, fn, keys, object, opaque, required, whole, } from "./config-schema.js";
-import { reviewedClassification } from "./catalog-drift.js";
+import { aliasCallIdentity } from "./provider-call-facts.js";
+import { isConnectorCallErrorCode } from "./errors.js";
 const budget = {
     ...object({
         kind: required(opaque({
@@ -50,16 +47,89 @@ export const CALL_ADMISSION = {
         return policy;
     },
 };
+/** Validate the common connector policy before a deployment can serve. */
+export const READ_ONLY = opaque({
+    check(value, path) {
+        if (typeof value !== "boolean")
+            throw new ConfigError(`${path} must be a boolean.`);
+    },
+});
 /** Options every maintained provider shares. */
 export const PROVIDER_COMMON = {
     ...keys("title", "authScope", "purpose", "instructions", "maxResultBytes"),
+    readOnly: READ_ONLY,
     callAdmission: CALL_ADMISSION,
 };
 const PROVIDER_NAME = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
-const KINDS = new Set(["mcp", "api", "composed", "dual"]);
+const BLOCK_KEY = /^[a-z][a-z0-9:-]*$/;
+/** A when-block marker, alone on its line. */
+const BLOCK_MARKER = /^<!--\s*(?:when:\s*([a-z][a-z0-9:-]*)|end)\s*-->$/;
 function nonEmpty(value) {
     return typeof value === "string" && value.trim() !== "";
 }
+/**
+ * Render a guide's selected when-blocks, or, with no selection, check them
+ * and return their keys. Markers stand alone on their lines and never nest.
+ * Removing an unselected block also removes the blank line it leaves, so
+ * paragraphs and tight lists keep their spacing.
+ */
+function guideBlocks(content, selected) {
+    const keys = new Set();
+    const kept = [];
+    let open;
+    let seam = false;
+    for (const line of content.split("\n")) {
+        const marker = BLOCK_MARKER.exec(line.trim());
+        if (marker) {
+            if (marker[1] !== undefined ? open !== undefined : open === undefined) {
+                throw new Error("when-blocks must open and close in turn, unnested");
+            }
+            if (marker[1] !== undefined)
+                keys.add((open = marker[1]));
+            else {
+                seam = selected !== undefined && !selected.has(open);
+                open = undefined;
+            }
+            continue;
+        }
+        if (/<!--\s*(?:when:|end\s*-->)/.test(line))
+            throw new Error("a when-block marker stands alone on its line");
+        if (open !== undefined && !selected?.has(open))
+            continue;
+        if (seam && !line.trim() && (kept.length === 0 || !kept.at(-1).trim()))
+            continue;
+        seam = false;
+        kept.push(line);
+    }
+    if (open !== undefined)
+        throw new Error(`the when-block "${open}" is never closed`);
+    return { text: kept.join("\n").trim(), keys };
+}
+/** A frozen copy: kit facts are review evidence `providers:generate` reads. */
+function kitFacts(kit) {
+    if (kit.errors && !isConnectorCallErrorCode(kit.errors.unknownId)) {
+        throw new Error("Provider kit errors.unknownId must be a ConnectorCallErrorCode.");
+    }
+    return Object.freeze({
+        operations: Object.freeze([...kit.operations]),
+        ...(kit.pageSize ? { pageSize: Object.freeze({ ...kit.pageSize }) } : {}),
+        ...(kit.hatch
+            ? {
+                hatch: Object.freeze({
+                    name: kit.hatch.name,
+                    verdicts: Object.freeze({ ...kit.hatch.verdicts }),
+                    ...(kit.hatch.paging ? { paging: kit.hatch.paging } : {}),
+                    ...(kit.hatch.fieldsRoot ? { fieldsRoot: kit.hatch.fieldsRoot } : {}),
+                }),
+            }
+            : {}),
+        ...(kit.errors
+            ? { errors: Object.freeze({ ...kit.errors, conflicts: Object.freeze([...kit.errors.conflicts]) }) }
+            : {}),
+        ...(kit.idempotencyKey !== undefined ? { idempotencyKey: kit.idempotencyKey } : {}),
+        ...(kit.refusesWithheld ? { refusesWithheld: true } : {}),
+    });
+}
 /**
  * Define a maintained provider: one validated description and one factory.
  *
@@ -75,23 +145,37 @@ export function defineProvider(definition) {
     if (!nonEmpty(definition.title)) {
         throw new Error(`${label} requires a non-empty title.`);
     }
-    if (!KINDS.has(definition.kind)) {
-        throw new Error(`${label} kind must be "mcp", "api", "composed", or "dual".`);
-    }
+    if (definition.kind !== "api")
+        throw new Error(`${label} kind must be "api".`);
     if (!nonEmpty(definition.skill?.content) || !nonEmpty(definition.skill.instructionsHeading)) {
         throw new Error(`${label} skill requires non-empty content and instructionsHeading.`);
     }
-    if (definition.classify !== undefined && definition.kind === "api") {
-        throw new Error(`${label} is an api() provider; annotate each authored tool instead of classifying a hosted catalog.`);
-    }
+    if (Object.hasOwn(definition, "classify"))
+        throw new Error(`${label} classify was removed; use ConnectaConfig.classification.`);
     if (!definition.options?.shape && !definition.options?.variants) {
         throw new Error(`${label} requires a closed options shape from optionsOf().`);
     }
-    // A validated, deep-frozen copy. The definition is what build and check
-    // tools read and what every later connector classifies with, so nothing
-    // reachable from it may change a verdict after review: neither the
-    // caller's original object nor a write through `factory.definition`.
-    const classify = definition.classify === undefined ? undefined : reviewedClassification(definition.classify, label);
+    const blocks = definition.blocks;
+    if (blocks !== undefined &&
+        (!Array.isArray(blocks.keys) ||
+            blocks.keys.length === 0 ||
+            !blocks.keys.every((key) => typeof key === "string" && BLOCK_KEY.test(key)) ||
+            new Set(blocks.keys).size !== blocks.keys.length ||
+            typeof blocks.select !== "function")) {
+        throw new Error(`${label} blocks require unique lowercase keys and a select function.`);
+    }
+    let used;
+    try {
+        used = guideBlocks(definition.skill.content).keys;
+    }
+    catch (error) {
+        throw new Error(`${label} skill: ${error instanceof Error ? error.message : String(error)}.`, { cause: error });
+    }
+    for (const key of used) {
+        if (!blocks?.keys.includes(key))
+            throw new Error(`${label} skill uses the when-block "${key}" its blocks omit.`);
+    }
+    // Freeze definition facts consumed by construction, generation and checks.
     if (typeof definition.create !== "function") {
         throw new Error(`${label} requires a create function.`);
     }
@@ -102,7 +186,8 @@ export function defineProvider(definition) {
             ...(definition.skill.fragments ? { fragments: Object.freeze(definition.skill.fragments) } : {}),
         }),
         ...(definition.bundle ? { bundle: Object.freeze({ ...definition.bundle }) } : {}),
-        ...(classify !== undefined ? { classify } : {}),
+        ...(blocks ? { blocks: Object.freeze({ keys: Object.freeze([...blocks.keys]), select: blocks.select }) } : {}),
+        ...(definition.kit ? { kit: kitFacts(definition.kit) } : {}),
     });
     const factoryName = `${frozen.name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())}()`;
     const factory = (id, options) => asProvider(frozen.name, frozen.options, id, options, (id, options) => {
@@ -125,15 +210,28 @@ export function defineProvider(definition) {
         const resolved = { ...options, purpose: options.purpose.trim() };
         const instructions = options.instructions?.trim();
         const connector = frozen.create(id, resolved, {
-            ...(frozen.classify !== undefined ? { classify: frozen.classify } : {}),
             connectorOptions: {
+                ...(options.readOnly !== undefined ? { readOnly: options.readOnly } : {}),
                 ...(options.authScope !== undefined ? { authScope: options.authScope } : {}),
                 ...(options.maxResultBytes !== undefined ? { maxResultBytes: options.maxResultBytes } : {}),
                 ...(options.callAdmission !== undefined ? { callAdmission: options.callAdmission } : {}),
             },
             usageGuide(input) {
                 const heading = input.heading ?? `${frozen.title} usage`;
-                const body = [...input.context, frozen.skill.content.trim()].join("\n\n");
+                let guide = frozen.skill.content.trim();
+                if (frozen.blocks) {
+                    const { keys, select } = frozen.blocks;
+                    const selected = select(resolved);
+                    if (!Array.isArray(selected))
+                        throw new Error(`${at} requires blocks.select() to return an array of keys.`);
+                    for (const key of selected) {
+                        if (!keys.includes(key)) {
+                            throw new Error(`${at} requires blocks.select() to return declared keys; it returned ${String(key)}.`);
+                        }
+                    }
+                    guide = guideBlocks(frozen.skill.content, new Set(selected)).text;
+                }
+                const body = [...input.context, guide].join("\n\n");
                 return {
                     content: `# ${heading}\n\n${body}\n` +
                         (instructions ? `\n## ${frozen.skill.instructionsHeading}\n\n${instructions}\n` : ""),
@@ -147,28 +245,13 @@ export function defineProvider(definition) {
         }
         return connector;
     });
-    // Frozen whole: build and check tools read `definition` to learn what the
-    // factory classifies, so neither replacing nor deleting it may take effect.
-    return Object.freeze(Object.assign(factory, { definition: frozen }));
-}
-/**
- * Attach the same validated definition to an existing provider constructor.
- * Its option policy stays in its builder during the mechanical folder move;
- * adopting defineProvider's common-value policy is a separate conversion.
- */
-export function asProviderFactory(definition) {
-    const frozen = defineProvider(definition).definition;
-    const create = definition.create;
-    const factory = (id, options) => asProvider(frozen.name, frozen.options, id, options, create);
-    Object.defineProperty(factory, "name", {
-        value: frozen.name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()),
-    });
+    // Build and check tools rely on this definition remaining attached.
     return Object.freeze(Object.assign(factory, { definition: frozen }));
 }
 /**
  * Build a maintained provider's connector: refuse unknown options and
  * accessors by path before the builder reads any of them, then stamp the
- * provider onto its description, so the operator surface can say "Linear"
+ * provider onto its description, so the operator surface can say "Stripe"
  * rather than "remote MCP". This is the same construction path defineProvider
  * uses; existing constructors retain their provider-specific option policy.
  */
@@ -178,6 +261,8 @@ function asProvider(provider, shape, id, options, build) {
     let connector;
     try {
         options = assertKnownOptions(options, `${factory}(${JSON.stringify(id)})`, shape);
+        if (options?.readOnly !== undefined)
+            READ_ONLY.parse(options.readOnly, `${factory}(${JSON.stringify(id)}).readOnly`);
         const admission = options == null ? undefined : options.callAdmission;
         if (admission !== undefined)
             CALL_ADMISSION.parse(admission, `${factory}(${JSON.stringify(id)}).callAdmission`);
@@ -188,12 +273,21 @@ function asProvider(provider, shape, id, options, build) {
     }
     const describe = connector.describe?.bind(connector);
     const ownDescribe = Object.getOwnPropertyDescriptor(connector, "describe");
+    const ownReadOnly = Object.getOwnPropertyDescriptor(connector, "readOnly");
     // Keep the receiver of prototype methods (including private fields). When
     // the description cannot be replaced, inherit the whole connector instead
-    // of copying it: decorators may inherit their id, methods, and review.
-    const stamped = Object.isExtensible(connector) && (!ownDescribe || ownDescribe.configurable)
+    // of copying it: decorators may inherit their id and methods.
+    const stamped = Object.isExtensible(connector) &&
+        (!ownDescribe || ownDescribe.configurable) &&
+        (options.readOnly === undefined || !ownReadOnly || ownReadOnly.configurable)
         ? connector
         : Object.create(connector);
+    // An inheriting stamp serves the connector itself, so it keeps its call identity.
+    if (stamped !== connector)
+        aliasCallIdentity(stamped, connector);
+    if (options.readOnly !== undefined) {
+        Object.defineProperty(stamped, "readOnly", { value: options.readOnly, enumerable: true, configurable: true });
+    }
     Object.defineProperty(stamped, "describe", {
         configurable: true,
         enumerable: false,

package/dist/providers/_shared/google/hatch.js

@@ -0,0 +1,91 @@
+// Opt-in plumbing only. Product PRs supply their reviewed literal verdicts.
+import { Effect } from "effect";
+import { ConnectorCallError } from "../../../errors.js";
+export function requireGoogleIndex(index) {
+    if (!index)
+        throw new Error("Google requests require their reviewed operation index.");
+    if (index.pathMatching !== "uri-template")
+        throw new Error('Google indexes require pathMatching: "uri-template".');
+}
+/** Independent of compact schema depth: only reviewed batch kinds can execute. */
+export function googleBatchGuard(body, options) {
+    if (!body || typeof body !== "object" || Array.isArray(body))
+        return "A Google batch body must be an object.";
+    const value = body;
+    const requests = value["requests"];
+    if (!Array.isArray(requests) || !requests.length || requests.length > (options.max ?? 100))
+        return `A Google batch needs 1–${options.max ?? 100} requests.`;
+    if (requests.some((request) => !request ||
+        typeof request !== "object" ||
+        Array.isArray(request) ||
+        Object.keys(request).length !== 1 ||
+        !options.kinds.includes(Object.keys(request)[0])))
+        return "Each Google batch request must contain exactly one reviewed request kind.";
+    const control = value["writeControl"];
+    if (options.revision &&
+        (!control || typeof control["requiredRevisionId"] !== "string" || !control["requiredRevisionId"].trim()))
+        return "This Google batch needs a nonempty writeControl.requiredRevisionId from a current read.";
+    return undefined;
+}
+/** Ensure a substituted named id still reaches the endpoint the tool declared. */
+export function googleNamedOperation(index, method, path, template) {
+    requireGoogleIndex(index);
+    if (index.resolve(method, path).op.path !== template)
+        throw new ConnectorCallError("invalid_args", "This Google id resolves to a different operation; no request was sent.");
+}
+export function googleHatchBinding(connection, options) {
+    requireGoogleIndex(options.index);
+    return {
+        index: options.index,
+        ...(options.wrapSend ? { warnings: true } : {}),
+        review: options.review,
+        ...(options.refusal ? { refusal: options.refusal } : {}),
+        refuse: (call) => {
+            for (const match of call.path.matchAll(/%([a-f0-9]{2})/gi))
+                if (/^[-A-Za-z0-9._~:]$/.test(String.fromCharCode(parseInt(match[1], 16))))
+                    return "Google paths must spell unreserved characters and action separators literally.";
+            if (call.headers && Object.keys(call.headers).length)
+                return "Google hatches do not accept caller headers.";
+            for (const key of Object.keys(call.query))
+                if ([
+                    "access_token",
+                    "oauth_token",
+                    "key",
+                    "callback",
+                    "upload_protocol",
+                    "uploadType",
+                    "userId",
+                    "quotaUser",
+                ].includes(key))
+                    return `Google query.${key} is owned by the deployment and cannot be selected by a caller.`;
+            if (call.query["alt"] !== undefined && call.query["alt"] !== "json")
+                return "Google hatches return JSON only; use a named content tool for media.";
+            return options.refuse?.(call);
+        },
+        send: (call, sendOptions) => Effect.suspend(() => {
+            // Capture the admitted wire request before the wrapper can inspect its copy.
+            const request = {
+                method: call.method,
+                path: call.path,
+                template: call.op.path,
+                query: Object.entries(call.query).flatMap(([name, value]) => value === undefined
+                    ? []
+                    : (Array.isArray(value) ? value : [value]).map((item) => [name, String(item)])),
+                headers: { accept: "application/json" },
+                ...(call.body === undefined ? {} : { json: JSON.stringify(call.body) }),
+            };
+            const optionsForSend = {
+                ...sendOptions,
+                ...(options.revisionGuarded?.(call) ? { flags: { revisionGuarded: true } } : {}),
+            };
+            let sent = false;
+            const send = () => Effect.suspend(() => {
+                if (sent)
+                    return Effect.die(new Error("A Google hatch wrapper may send its admitted request only once."));
+                sent = true;
+                return connection.sendPath(request, optionsForSend);
+            });
+            return options.wrapSend ? options.wrapSend(structuredClone(call), send) : send();
+        }),
+    };
+}