@aexhq/sdk 0.46.4-canary → 0.50.0

package/dist/_contracts/schemas/submission-request.d.ts

@@ -1,158 +0,0 @@
-/**
- * Schema for the session-submission REQUEST envelope — the outermost object a
- * platform adapter hands {@link parseSessionSubmissionRequest}: workspace and
- * idempotency identity, the submission brief itself, the runtime dials, and the
- * vaulted `secrets` side-channel.
- *
- * Every member mounts the schema that already owns its vocabulary, so the
- * envelope is one parse rather than a key gate followed by ten. What stays on
- * the parser below is what a schema cannot state: the duration string is
- * DECODED to milliseconds and bounded there, the vaulted bundle and the brief
- * are cross-checked against each other, and the credential-named-field sweep
- * runs over the parsed value.
- *
- * Declaration order is the permitted-key order reported on an unknown field, and
- * `test/allowed-keys-parser-golden.test.ts` pins the resulting sentence.
- *
- * The wire path is `submission`, not `request`: the envelope has always reported
- * itself under that name (`submission.workspaceId is not an allowed field`).
- * `timeout` is the wire duration string; the parsed request carries `timeoutMs`,
- * so the two never appear in the same shape.
- */
-import * as z from "zod/mini";
-/** Wire shape of the submission request envelope. */
-export declare const SessionSubmissionRequestSchema: z.ZodMiniObject<{
-    workspaceId: z.ZodMiniString<string>;
-    idempotencyKey: z.ZodMiniString<string>;
-    submission: z.ZodMiniObject<{
-        model: z.ZodMiniString<string>;
-        system: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        prompt: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniUnknown>]>;
-        assets: z.ZodMiniObject<{
-            files: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
-                name: z.ZodMiniString<string>;
-                mountPath: z.ZodMiniString<string>;
-                kind: z.ZodMiniLiteral<"file">;
-                resourceId: z.ZodMiniString<string>;
-                version: z.ZodMiniNumber<number>;
-                assetId: z.ZodMiniString<string>;
-                contentHash: z.ZodMiniString<string>;
-            }, z.core.$strict>>>;
-            skills: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
-                name: z.ZodMiniString<string>;
-                description: z.ZodMiniString<string>;
-                kind: z.ZodMiniLiteral<"skill">;
-                resourceId: z.ZodMiniString<string>;
-                version: z.ZodMiniNumber<number>;
-                assetId: z.ZodMiniString<string>;
-                contentHash: z.ZodMiniString<string>;
-            }, z.core.$strict>>>;
-            tools: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
-                name: z.ZodMiniString<string>;
-                description: z.ZodMiniString<string>;
-                input_schema: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
-                entry: z.ZodMiniString<string>;
-                kind: z.ZodMiniLiteral<"tool">;
-                resourceId: z.ZodMiniString<string>;
-                version: z.ZodMiniNumber<number>;
-                assetId: z.ZodMiniString<string>;
-                contentHash: z.ZodMiniString<string>;
-            }, z.core.$strict>>>;
-            instructions: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
-                name: z.ZodMiniString<string>;
-                kind: z.ZodMiniLiteral<"instruction">;
-                resourceId: z.ZodMiniString<string>;
-                version: z.ZodMiniNumber<number>;
-                assetId: z.ZodMiniString<string>;
-                contentHash: z.ZodMiniString<string>;
-            }, z.core.$strict>>>;
-        }, z.core.$strict>;
-        mcpServers: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnknown>>;
-        secretEnv: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>>;
-        environment: z.ZodMiniOptional<z.ZodMiniObject<{
-            networking: z.ZodMiniOptional<z.ZodMiniObject<{
-                mode: z.ZodMiniOptional<z.ZodMiniEnum<{
-                    limited: "limited";
-                    open: "open";
-                }>>;
-                allowedHosts: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
-            }, z.core.$strict>>;
-            packages: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
-                name: z.ZodMiniString<string>;
-                version: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            }, z.core.$strict>>>;
-            envVars: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
-        }, z.core.$strict>>;
-        securityProfile: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniEnum<{
-            strict: "strict";
-            standard: "standard";
-            developer: "developer";
-        }>>>;
-        metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
-        fileCapture: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniObject<{
-            allowedDirs: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnknown>>;
-            deniedDirs: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnknown>>;
-            captureTimeoutMs: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-            maxFileBytes: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-            maxTotalBytes: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-            maxFiles: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-        }, z.core.$strict>>>;
-        builtinTools: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"default">, z.ZodMiniLiteral<"none">, z.ZodMiniArray<z.ZodMiniUnknown>]>>>;
-        outputMode: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniEnum<{
-            buffered: "buffered";
-            stream: "stream";
-        }>>>;
-        responseFormat: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
-            kind: z.ZodMiniLiteral<"text">;
-        }, z.core.$strict>, z.ZodMiniObject<{
-            kind: z.ZodMiniLiteral<"json_schema">;
-            schema: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
-            strict: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-            name: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        }, z.core.$strict>], "kind">>>;
-        approvalGate: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniObject<{
-            tools: z.ZodMiniArray<z.ZodMiniString<string>>;
-        }, z.core.$strict>>>;
-        platform: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniObject<{
-            systemPrompt: z.ZodMiniOptional<z.ZodMiniEnum<{
-                default: "default";
-                off: "off";
-            }>>;
-        }, z.core.$strict>>>;
-    }, z.core.$strict>;
-    runtimeSize: z.ZodMiniOptional<z.ZodMiniEnum<{
-        "0.25cpu-1gb": "0.25cpu-1gb";
-        "0.5cpu-4gb": "0.5cpu-4gb";
-        "1cpu-6gb": "1cpu-6gb";
-        "2cpu-8gb": "2cpu-8gb";
-        "4cpu-12gb": "4cpu-12gb";
-    }>>;
-    runtimeKind: z.ZodMiniOptional<z.ZodMiniEnum<{
-        container: "container";
-        spot_container: "spot_container";
-        lambda: "lambda";
-    }>>;
-    timeout: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    webhook: z.ZodMiniOptional<z.ZodMiniObject<{
-        url: z.ZodMiniString<string>;
-    }, z.core.$strict>>;
-    limits: z.ZodMiniOptional<z.ZodMiniObject<{
-        maxConcurrentChildSessions: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-        maxSubagentDepth: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-        maxSpendUsd: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-        maxTurns: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-        maxStepsPerTurn: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-    }, z.core.$strict>>;
-    machine: z.ZodMiniOptional<z.ZodMiniObject<{
-        spot: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-    }, z.core.$strict>>;
-    secrets: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniObject<{
-        mcpServers: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
-            name: z.ZodMiniString<string>;
-            url: z.ZodMiniString<string>;
-            headers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
-        }, z.core.$strict>>>;
-        envSecrets: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-export type SessionSubmissionRequestWire = z.infer<typeof SessionSubmissionRequestSchema>;

package/dist/_contracts/schemas/submission-request.js

@@ -1,49 +0,0 @@
-/**
- * Schema for the session-submission REQUEST envelope — the outermost object a
- * platform adapter hands {@link parseSessionSubmissionRequest}: workspace and
- * idempotency identity, the submission brief itself, the runtime dials, and the
- * vaulted `secrets` side-channel.
- *
- * Every member mounts the schema that already owns its vocabulary, so the
- * envelope is one parse rather than a key gate followed by ten. What stays on
- * the parser below is what a schema cannot state: the duration string is
- * DECODED to milliseconds and bounded there, the vaulted bundle and the brief
- * are cross-checked against each other, and the credential-named-field sweep
- * runs over the parsed value.
- *
- * Declaration order is the permitted-key order reported on an unknown field, and
- * `test/allowed-keys-parser-golden.test.ts` pins the resulting sentence.
- *
- * The wire path is `submission`, not `request`: the envelope has always reported
- * itself under that name (`submission.workspaceId is not an allowed field`).
- * `timeout` is the wire duration string; the parsed request carries `timeoutMs`,
- * so the two never appear in the same shape.
- */
-import * as z from "zod/mini";
-import { RuntimeKindSchema } from "./runtime-kind.js";
-import { RuntimeSizeSchema, SessionTimeoutSchema } from "./runtime-sizes.js";
-import { SessionLimitsSchema } from "./session-limits.js";
-import { SessionMachineSchema } from "./session-machine.js";
-import { SessionWebhookSchema } from "./session-webhook.js";
-import { SubmissionSchema } from "./submission-body.js";
-import { InlineSecretsSchema } from "./submission-secrets.js";
-import { nonEmptyString, wireObject } from "./wire.js";
-const REQUEST = "submission";
-/** Wire shape of the submission request envelope. */
-export const SessionSubmissionRequestSchema = wireObject(REQUEST, {
-    workspaceId: nonEmptyString("workspaceId"),
-    idempotencyKey: nonEmptyString("idempotencyKey"),
-    submission: SubmissionSchema,
-    runtimeSize: z.optional(RuntimeSizeSchema),
-    runtimeKind: z.optional(RuntimeKindSchema),
-    // A string here, a bounded millisecond deadline after `parseSessionTimeout`
-    // decodes it: `"90m"` and `"5400000"` are the same deadline and only the
-    // decoded value can be judged against the accepted window.
-    timeout: z.optional(SessionTimeoutSchema),
-    webhook: z.optional(SessionWebhookSchema),
-    limits: z.optional(SessionLimitsSchema),
-    machine: z.optional(SessionMachineSchema),
-    // Absent or null collapses to an empty bundle: under managed gateway keys a
-    // run needs no provider key, so an empty bundle is always admissible.
-    secrets: z.optional(z.nullable(InlineSecretsSchema))
-});

package/dist/_contracts/schemas/submission-secrets.d.ts

@@ -1,47 +0,0 @@
-/**
- * Schemas for the `secrets` channel — the half of a submission that is vaulted,
- * excluded from the idempotency hash, and never echoed back.
- *
- * Mounted under {@link InlineSecretsSchema}; nested schemas anchor their message
- * paths on `secrets` for the reason documented in `submission-environment.ts`.
- */
-import * as z from "zod/mini";
-/**
- * The array owns the per-entry field messages as well as the duplicate check.
- *
- * Both need the entry's INDEX — `secrets.mcpServers[0].name` — and a check
- * running on the element schema cannot see where in the array it sits: the
- * low-level parse payload carries the value and the issue list, not a path. The
- * element schema keeps what it can state on its own (shape and the allow-list);
- * anything that has to name its position is stated here.
- */
-export declare const McpServerSecretsSchema: z.ZodMiniArray<z.ZodMiniObject<{
-    name: z.ZodMiniString<string>;
-    url: z.ZodMiniString<string>;
-    headers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
-}, z.core.$strict>>;
-/**
- * `envSecrets` as a map of env var name to value.
- *
- * One ordered check for the same reason as `envVars`: the key-name rule and the
- * value rule have distinct messages and the key rule must win.
- */
-export declare const EnvSecretsSchema: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
-/**
- * The inline secrets bundle.
- *
- * A key in the platform-internal namespace gets its own message. The generic
- * unknown-field error still wins when it comes first in the caller's object —
- * `unrecognized_keys` reports keys in input order and only the first is named,
- * which is the precedence the parser had and the golden tests pin.
- */
-export declare const InlineSecretsSchema: z.ZodMiniObject<{
-    mcpServers: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
-        name: z.ZodMiniString<string>;
-        url: z.ZodMiniString<string>;
-        headers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
-    }, z.core.$strict>>>;
-    envSecrets: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>;
-}, z.core.$strict>;
-/** An empty map carries no secrets, so it is dropped rather than landed empty. */
-export declare function normalizeEnvSecrets(envSecrets: Record<string, unknown> | undefined): Readonly<Record<string, string>> | undefined;

package/dist/_contracts/schemas/submission-secrets.js

@@ -1,108 +0,0 @@
-/**
- * Schemas for the `secrets` channel — the half of a submission that is vaulted,
- * excluded from the idempotency hash, and never echoed back.
- *
- * Mounted under {@link InlineSecretsSchema}; nested schemas anchor their message
- * paths on `secrets` for the reason documented in `submission-environment.ts`.
- */
-import * as z from "zod/mini";
-import { PLATFORM_INTERNAL_SECRET_PREFIX, SECRET_ENV_NAME_PATTERN } from "../submission-limits.js";
-import { UnknownFieldError } from "../unknown-field-error.js";
-import { indexedPath, wireObject, wirePath } from "./wire.js";
-const SECRETS = "secrets";
-const MCP_SERVERS = `${SECRETS}.mcpServers`;
-const McpServerSecretSchema = wireObject(
-// Depth-proof: the bundle is also mounted under the request envelope, and a
-// path folded from the whole reported position would double the segment
-// there. See `indexedPath`.
-indexedPath(MCP_SERVERS), {
-    name: z.string(),
-    url: z.string(),
-    headers: z.optional(z.record(z.string(), z.string()))
-}, {
-    unknownKey: (path, key) => `${path}.${key} is not an allowed field; permitted: name, url, headers`
-});
-/**
- * The array owns the per-entry field messages as well as the duplicate check.
- *
- * Both need the entry's INDEX — `secrets.mcpServers[0].name` — and a check
- * running on the element schema cannot see where in the array it sits: the
- * low-level parse payload carries the value and the issue list, not a path. The
- * element schema keeps what it can state on its own (shape and the allow-list);
- * anything that has to name its position is stated here.
- */
-export const McpServerSecretsSchema = z
-    .array(McpServerSecretSchema, { error: `${MCP_SERVERS} must be an array` })
-    .check(z.check((payload) => {
-    const entries = payload.value;
-    const reject = (message) => {
-        payload.issues.push({ code: "custom", message, input: payload.value });
-    };
-    const seen = new Set();
-    for (const [index, entry] of entries.entries()) {
-        const base = wirePath(MCP_SERVERS, [index]);
-        if (typeof entry.name !== "string" || entry.name.length === 0) {
-            reject(`${base}.name must be a non-empty string`);
-            return;
-        }
-        if (typeof entry.url !== "string" || entry.url.length === 0) {
-            reject(`${base}.url must be a non-empty string`);
-            return;
-        }
-        if (seen.has(entry.name)) {
-            reject(`${MCP_SERVERS} duplicate name: ${entry.name}`);
-            return;
-        }
-        seen.add(entry.name);
-    }
-}));
-/**
- * `envSecrets` as a map of env var name to value.
- *
- * One ordered check for the same reason as `envVars`: the key-name rule and the
- * value rule have distinct messages and the key rule must win.
- */
-export const EnvSecretsSchema = z
-    .record(z.string(), z.unknown(), { error: `${SECRETS}.envSecrets must be an object` })
-    .check(z.check((payload) => {
-    const reject = (message) => {
-        payload.issues.push({ code: "custom", message, input: payload.value });
-    };
-    for (const [envName, entry] of Object.entries(payload.value)) {
-        if (!SECRET_ENV_NAME_PATTERN.test(envName)) {
-            reject(`${SECRETS}.envSecrets key "${envName}" must be a valid env var name matching ${SECRET_ENV_NAME_PATTERN.source}`);
-            return;
-        }
-        if (typeof entry !== "string" || entry.length === 0) {
-            reject(`${SECRETS}.envSecrets.${envName} must be a non-empty string`);
-            return;
-        }
-    }
-}));
-/**
- * The inline secrets bundle.
- *
- * A key in the platform-internal namespace gets its own message. The generic
- * unknown-field error still wins when it comes first in the caller's object —
- * `unrecognized_keys` reports keys in input order and only the first is named,
- * which is the precedence the parser had and the golden tests pin.
- */
-export const InlineSecretsSchema = wireObject(SECRETS, {
-    mcpServers: z.optional(McpServerSecretsSchema),
-    envSecrets: z.optional(EnvSecretsSchema)
-}, {
-    // Returns an Error instance, not a string: callers get `objectPath`,
-    // `unknownKey` and the ordered `permittedKeys` as structured fields. The
-    // reserved-namespace case deliberately returns a plain Error — it is not an
-    // unknown field, it is a field the caller may not set.
-    unknownKey: (path, key, permitted) => key.startsWith(PLATFORM_INTERNAL_SECRET_PREFIX)
-        ? new Error(`${path}.${key} uses the platform-internal ${PLATFORM_INTERNAL_SECRET_PREFIX} namespace and may not be set by callers`)
-        : new UnknownFieldError(path, key, permitted)
-});
-/** An empty map carries no secrets, so it is dropped rather than landed empty. */
-export function normalizeEnvSecrets(envSecrets) {
-    if (envSecrets === undefined || Object.keys(envSecrets).length === 0) {
-        return undefined;
-    }
-    return { ...envSecrets };
-}

package/dist/_contracts/schemas/wire.d.ts

@@ -1,118 +0,0 @@
-/**
- * Shared machinery for schema-backed wire parsing.
- *
- * Every module in this directory imports **only `zod/mini`**. The published SDK
- * inlines this package, and full Zod's method-chained API defeats tree-shaking
- * (measured: 63.7 KB gzip for a trivial schema, against 4.3 KB for the same
- * schema in mini). Build-time tooling that needs the classic surface — the
- * OpenAPI generator — imports full `zod` off these same schema objects, which is
- * sound because both entrypoints construct the same core classes.
- *
- * The house parser idiom this replaces paired a hand-written allow-list with
- * `defineAllowedKeys<T>()`, a compile-time proof that the runtime list named
- * every key of the TypeScript interface and no others. That proof is not
- * preserved here so much as made unnecessary: the schema *is* the type, so
- * {@link wireObject} reads the ordered permitted list off the shape it was
- * built from and there is no second list to disagree with the first.
- */
-import * as z from "zod/mini";
-/**
- * Wording for the two diagnostics a strict wire object raises on its own
- * behalf. Families differ ("is not an allowed field; permitted: …" against "is
- * not allowed; permitted: …" against "contains unexpected field: …"), so each
- * supplies the text it already emits. The ordered key list handed to
- * {@link WireObjectText.unknownKey} always comes from the schema shape.
- */
-export interface WireObjectText {
-    /** Raised when the input is not an object at all. */
-    readonly notObject: (path: string) => string;
-    /**
-     * Raised for the first key the shape does not declare.
-     *
-     * Return an `Error` instance rather than a string to keep a structured
-     * diagnostic — `UnknownFieldError` carries `objectPath`, `unknownKey` and the
-     * ordered `permittedKeys` as fields. Zod's message channel is strings only, so
-     * {@link parseWire} re-invokes this to recover the instance at the throw site;
-     * implementations must therefore be pure. Only applies at the root of the
-     * parsed schema; a nested unknown key surfaces as its message alone.
-     */
-    readonly unknownKey: (path: string, key: string, permitted: readonly string[]) => string | Error;
-}
-/**
- * Render a wire path from a base and the position Zod reports an issue at:
- * `submission.environment.packages` + `[0]` -> `submission.environment.packages[0]`.
- *
- * Array indices render as `[0]` and object keys as `.name`, matching the paths
- * the hand-written parsers interpolate into their messages.
- */
-export declare function wirePath(base: string, issuePath: readonly PropertyKey[]): string;
-/**
- * The wire path of an object that sits at an INDEXED position in a list —
- * `secrets.mcpServers[2]`, `submission.assets.files[0]` — derived from where
- * Zod reports the issue rather than from the whole reported position.
- *
- * Prefer this over {@link wirePath} for anything mounted inside an array.
- * Zod reports a position relative to the schema the parse STARTED at, so a
- * schema that renders its own path by folding the whole issue path is only
- * correct at one mount depth: parse the same object one level lower and the
- * segment doubles (`submission.environment.environment.packages[0]`). The
- * element's own diagnostics — not-an-object and rejected-key — always report at
- * the element's position, so the element INDEX is the last segment whatever
- * sits above it, and reading just that segment makes the message depth-proof.
- */
-export declare function indexedPath(base: string): (issuePath: readonly PropertyKey[]) => string;
-/**
- * The path of a FIELD on an element at an indexed position:
- * `submission.assets.files[0].mountPath`.
- *
- * Depth-proof for the same reason as {@link indexedPath}, reading the last two
- * segments — the element index and the field name — off the reported position.
- */
-export declare function indexedFieldPath(base: string, issuePath: readonly PropertyKey[] | undefined): string;
-/** The last segment of a reported position — a record key, or an array index. */
-export declare function lastSegment(issuePath: readonly PropertyKey[] | undefined): string;
-/**
- * A required, non-empty string reported under `path`.
- *
- * The type failure and the emptiness failure share one message because the
- * `requireString(value, path)` ladder this replaces collapsed them, and `abort`
- * keeps the second from firing on a value that never cleared the first.
- */
-export declare function nonEmptyString(path: string): z.ZodMiniString<string>;
-/**
- * A strict object schema that reports unknown keys and non-object input in the
- * caller's own words.
- *
- * `path` is the wire path the surrounding parser reports errors under
- * (`"webhook"`, `"submission.environment"`), not a schema name. Pass a function
- * when the object sits inside an array and the path carries an index — it
- * receives the issue's position, which {@link wirePath} renders.
- */
-export declare function wireObject<Shape extends z.core.$ZodLooseShape>(path: string | ((issuePath: readonly PropertyKey[]) => string), shape: Shape, text?: Partial<WireObjectText>): z.ZodMiniObject<Shape, z.core.$strict>;
-/**
- * Map a failed parse onto the package's error surface: a plain `Error` carrying
- * the message the schema declared.
- *
- * Deliberately not a `ZodError`. Callers wrap parsers in `withContractParseError`,
- * which brands the thrown error with non-enumerable metadata and asserts the
- * error has no enumerable own keys of its own; a `ZodError` carries `issues`
- * and would break that contract as well as leak the schema library into a
- * public error shape.
- */
-export declare function errorFromZod(error: z.core.$ZodError): Error;
-/**
- * Drop explicit `undefined` from optional properties.
- *
- * `z.infer` of an optional field yields `field?: T | undefined`, which under
- * `exactOptionalPropertyTypes` is NOT assignable to the package's `field?: T`
- * interfaces — an inferred value may carry the key with an `undefined` value,
- * and those interfaces promise it is either absent or a `T`.
- *
- * A `normalize*()` function is where that promise is actually kept, since it is
- * the step that drops absent fields, so it is where this type belongs.
- */
-export type Present<T> = {
-    [K in keyof T]?: Exclude<T[K], undefined>;
-};
-/** Parse `input` against `schema`, throwing the family's own error text on failure. */
-export declare function parseWire<Schema extends z.core.$ZodType>(schema: Schema, input: unknown): z.infer<Schema>;

package/dist/_contracts/schemas/wire.js

@@ -1,171 +0,0 @@
-/**
- * Shared machinery for schema-backed wire parsing.
- *
- * Every module in this directory imports **only `zod/mini`**. The published SDK
- * inlines this package, and full Zod's method-chained API defeats tree-shaking
- * (measured: 63.7 KB gzip for a trivial schema, against 4.3 KB for the same
- * schema in mini). Build-time tooling that needs the classic surface — the
- * OpenAPI generator — imports full `zod` off these same schema objects, which is
- * sound because both entrypoints construct the same core classes.
- *
- * The house parser idiom this replaces paired a hand-written allow-list with
- * `defineAllowedKeys<T>()`, a compile-time proof that the runtime list named
- * every key of the TypeScript interface and no others. That proof is not
- * preserved here so much as made unnecessary: the schema *is* the type, so
- * {@link wireObject} reads the ordered permitted list off the shape it was
- * built from and there is no second list to disagree with the first.
- */
-import * as z from "zod/mini";
-const defaultText = {
-    notObject: (path) => `${path} must be an object`,
-    unknownKey: (path, key, permitted) => `${path}.${key} is not an allowed field; permitted: ${permitted.join(", ")}`
-};
-const wireObjectMeta = new WeakMap();
-/**
- * Render a wire path from a base and the position Zod reports an issue at:
- * `submission.environment.packages` + `[0]` -> `submission.environment.packages[0]`.
- *
- * Array indices render as `[0]` and object keys as `.name`, matching the paths
- * the hand-written parsers interpolate into their messages.
- */
-export function wirePath(base, issuePath) {
-    return issuePath.reduce((rendered, segment) => typeof segment === "number" ? `${rendered}[${segment}]` : `${rendered}.${String(segment)}`, base);
-}
-/**
- * The wire path of an object that sits at an INDEXED position in a list —
- * `secrets.mcpServers[2]`, `submission.assets.files[0]` — derived from where
- * Zod reports the issue rather than from the whole reported position.
- *
- * Prefer this over {@link wirePath} for anything mounted inside an array.
- * Zod reports a position relative to the schema the parse STARTED at, so a
- * schema that renders its own path by folding the whole issue path is only
- * correct at one mount depth: parse the same object one level lower and the
- * segment doubles (`submission.environment.environment.packages[0]`). The
- * element's own diagnostics — not-an-object and rejected-key — always report at
- * the element's position, so the element INDEX is the last segment whatever
- * sits above it, and reading just that segment makes the message depth-proof.
- */
-export function indexedPath(base) {
-    return (issuePath) => `${base}[${String(issuePath[issuePath.length - 1] ?? 0)}]`;
-}
-/**
- * The path of a FIELD on an element at an indexed position:
- * `submission.assets.files[0].mountPath`.
- *
- * Depth-proof for the same reason as {@link indexedPath}, reading the last two
- * segments — the element index and the field name — off the reported position.
- */
-export function indexedFieldPath(base, issuePath) {
-    const path = issuePath ?? [];
-    return `${base}[${String(path[path.length - 2] ?? 0)}].${String(path[path.length - 1] ?? "")}`;
-}
-/** The last segment of a reported position — a record key, or an array index. */
-export function lastSegment(issuePath) {
-    const segment = issuePath?.[issuePath.length - 1];
-    return segment === undefined ? "" : String(segment);
-}
-/**
- * A required, non-empty string reported under `path`.
- *
- * The type failure and the emptiness failure share one message because the
- * `requireString(value, path)` ladder this replaces collapsed them, and `abort`
- * keeps the second from firing on a value that never cleared the first.
- */
-export function nonEmptyString(path) {
-    const message = `${path} must be a non-empty string`;
-    return z.string({ error: message }).check(z.minLength(1, { error: message, abort: true }));
-}
-/**
- * A strict object schema that reports unknown keys and non-object input in the
- * caller's own words.
- *
- * `path` is the wire path the surrounding parser reports errors under
- * (`"webhook"`, `"submission.environment"`), not a schema name. Pass a function
- * when the object sits inside an array and the path carries an index — it
- * receives the issue's position, which {@link wirePath} renders.
- */
-export function wireObject(path, shape, text = {}) {
-    const permitted = Object.freeze(Object.keys(shape));
-    const notObject = text.notObject ?? defaultText.notObject;
-    const unknownKey = text.unknownKey ?? defaultText.unknownKey;
-    const resolvePath = typeof path === "string" ? () => path : (issuePath) => path(issuePath);
-    const schema = z.strictObject(shape, {
-        error: (issue) => issue.code === "unrecognized_keys"
-            ? messageOf(unknownKey(resolvePath(issue.path ?? []), issue.keys[0] ?? "", permitted))
-            : notObject(resolvePath(issue.path ?? []))
-    });
-    wireObjectMeta.set(schema, { resolvePath, permitted, unknownKey });
-    return schema;
-}
-function messageOf(text) {
-    return typeof text === "string" ? text : text.message;
-}
-/**
- * The issue a hand-written parser would have raised first.
- *
- * The parsers these schemas replace validate an object top-down — shape, then
- * the allow-list, then each field in turn, recursing as they go — so the
- * shallowest complaint surfaces and deeper ones never run. Zod collects every
- * issue instead. Ordering by path depth, with a rejected key ahead of a field
- * error at the same depth, reproduces the original traversal, which the
- * error-precedence tests pin.
- */
-function primaryIssue(issues) {
-    return [...issues].sort((left, right) => left.path.length - right.path.length || issueRank(left) - issueRank(right))[0];
-}
-function issueRank(issue) {
-    return issue.code === "unrecognized_keys" ? 0 : 1;
-}
-/**
- * Map a failed parse onto the package's error surface: a plain `Error` carrying
- * the message the schema declared.
- *
- * Deliberately not a `ZodError`. Callers wrap parsers in `withContractParseError`,
- * which brands the thrown error with non-enumerable metadata and asserts the
- * error has no enumerable own keys of its own; a `ZodError` carries `issues`
- * and would break that contract as well as leak the schema library into a
- * public error shape.
- */
-export function errorFromZod(error) {
-    return new Error(primaryIssue(error.issues)?.message ?? "invalid input");
-}
-/** Parse `input` against `schema`, throwing the family's own error text on failure. */
-export function parseWire(schema, input) {
-    const meta = wireObjectMeta.get(schema);
-    if (meta && input !== null && typeof input === "object" && !Array.isArray(input)) {
-        // Zod deliberately skips `__proto__` while collecting unknown keys so a
-        // plain-object output cannot have its prototype replaced. That safety
-        // rule must not turn an attacker-controlled field into an accepted field;
-        // recover the strict wire-object diagnostic before Zod sees the input.
-        const unknownKey = Object.keys(input).find((key) => !meta.permitted.includes(key));
-        if (unknownKey !== undefined) {
-            const diagnostic = meta.unknownKey(meta.resolvePath([]), unknownKey, meta.permitted);
-            throw typeof diagnostic === "string" ? new Error(diagnostic) : diagnostic;
-        }
-    }
-    const result = z.safeParse(schema, input);
-    if (!result.success) {
-        throw structuredError(schema, result.error) ?? errorFromZod(result.error);
-    }
-    return result.data;
-}
-/**
- * Recover the family's own `Error` subclass for an unknown key at the root of
- * this schema, when it declared one.
- *
- * Zod carries messages, not error instances, so the structured diagnostic has to
- * be rebuilt here — this is the one place that holds both the schema and the
- * failure.
- */
-function structuredError(schema, error) {
-    const issue = primaryIssue(error.issues);
-    if (issue?.code !== "unrecognized_keys" || issue.path.length > 0) {
-        return undefined;
-    }
-    const meta = wireObjectMeta.get(schema);
-    if (!meta) {
-        return undefined;
-    }
-    const rebuilt = meta.unknownKey(meta.resolvePath(issue.path), issue.keys[0] ?? "", meta.permitted);
-    return typeof rebuilt === "string" ? undefined : rebuilt;
-}