@aexhq/sdk 0.46.5-canary → 0.50.0

package/dist/_contracts/schemas/response-workspace.d.ts

@@ -1,225 +0,0 @@
-/**
- * Response schemas for the versioned `workspace.*` resource families and for the
- * GDPR workspace erase.
- *
- * The four resource kinds share one server projection (`publicResource`) plus a
- * per-kind metadata spread, so they are built here from one shared shape rather
- * than written out four times. The per-kind extras are exactly the whitelist the
- * publish path stores: `mountPath` for a file, `description` for a skill,
- * `description` + `entry` + `input_schema` for a tool, and nothing at all for an
- * instruction.
- *
- * Divergence from the declared types: `WorkspaceResourceRecordFields` declares
- * `updatedAt?`, and the server projection never emits one. It stays optional
- * here — our own published type permits it, so a deployment that starts sending
- * it is not drift.
- */
-import * as z from "zod/mini";
-export declare const WorkspaceFileRecordSchema: z.ZodMiniObject<{
-    mountPath: z.ZodMiniString<string>;
-    resourceId: z.ZodMiniString<string>;
-    name: z.ZodMiniString<string>;
-    version: z.ZodMiniNumberFormat;
-    assetId: z.ZodMiniString<string>;
-    contentHash: z.ZodMiniString<string>;
-    sizeBytes: z.ZodMiniNumberFormat;
-    contentType: z.ZodMiniString<string>;
-    createdAt: z.ZodMiniString<string>;
-    updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    kind: z.ZodMiniLiteral<"file">;
-}, z.core.$strict>;
-export declare const WorkspaceSkillRecordSchema: z.ZodMiniObject<{
-    description: z.ZodMiniString<string>;
-    resourceId: z.ZodMiniString<string>;
-    name: z.ZodMiniString<string>;
-    version: z.ZodMiniNumberFormat;
-    assetId: z.ZodMiniString<string>;
-    contentHash: z.ZodMiniString<string>;
-    sizeBytes: z.ZodMiniNumberFormat;
-    contentType: z.ZodMiniString<string>;
-    createdAt: z.ZodMiniString<string>;
-    updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    kind: z.ZodMiniLiteral<"skill">;
-}, z.core.$strict>;
-export declare const WorkspaceToolRecordSchema: z.ZodMiniObject<{
-    description: z.ZodMiniString<string>;
-    entry: z.ZodMiniString<string>;
-    input_schema: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
-    resourceId: z.ZodMiniString<string>;
-    name: z.ZodMiniString<string>;
-    version: z.ZodMiniNumberFormat;
-    assetId: z.ZodMiniString<string>;
-    contentHash: z.ZodMiniString<string>;
-    sizeBytes: z.ZodMiniNumberFormat;
-    contentType: z.ZodMiniString<string>;
-    createdAt: z.ZodMiniString<string>;
-    updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    kind: z.ZodMiniLiteral<"tool">;
-}, z.core.$strict>;
-export declare const WorkspaceInstructionRecordSchema: z.ZodMiniObject<{
-    resourceId: z.ZodMiniString<string>;
-    name: z.ZodMiniString<string>;
-    version: z.ZodMiniNumberFormat;
-    assetId: z.ZodMiniString<string>;
-    contentHash: z.ZodMiniString<string>;
-    sizeBytes: z.ZodMiniNumberFormat;
-    contentType: z.ZodMiniString<string>;
-    createdAt: z.ZodMiniString<string>;
-    updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    kind: z.ZodMiniLiteral<"instruction">;
-}, z.core.$strict>;
-export declare const WorkspaceFileResponseSchema: z.ZodMiniObject<{
-    resource: z.ZodMiniObject<{
-        mountPath: z.ZodMiniString<string>;
-        resourceId: z.ZodMiniString<string>;
-        name: z.ZodMiniString<string>;
-        version: z.ZodMiniNumberFormat;
-        assetId: z.ZodMiniString<string>;
-        contentHash: z.ZodMiniString<string>;
-        sizeBytes: z.ZodMiniNumberFormat;
-        contentType: z.ZodMiniString<string>;
-        createdAt: z.ZodMiniString<string>;
-        updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        kind: z.ZodMiniLiteral<"file">;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const WorkspaceSkillResponseSchema: z.ZodMiniObject<{
-    resource: z.ZodMiniObject<{
-        description: z.ZodMiniString<string>;
-        resourceId: z.ZodMiniString<string>;
-        name: z.ZodMiniString<string>;
-        version: z.ZodMiniNumberFormat;
-        assetId: z.ZodMiniString<string>;
-        contentHash: z.ZodMiniString<string>;
-        sizeBytes: z.ZodMiniNumberFormat;
-        contentType: z.ZodMiniString<string>;
-        createdAt: z.ZodMiniString<string>;
-        updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        kind: z.ZodMiniLiteral<"skill">;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const WorkspaceToolResponseSchema: z.ZodMiniObject<{
-    resource: z.ZodMiniObject<{
-        description: z.ZodMiniString<string>;
-        entry: z.ZodMiniString<string>;
-        input_schema: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
-        resourceId: z.ZodMiniString<string>;
-        name: z.ZodMiniString<string>;
-        version: z.ZodMiniNumberFormat;
-        assetId: z.ZodMiniString<string>;
-        contentHash: z.ZodMiniString<string>;
-        sizeBytes: z.ZodMiniNumberFormat;
-        contentType: z.ZodMiniString<string>;
-        createdAt: z.ZodMiniString<string>;
-        updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        kind: z.ZodMiniLiteral<"tool">;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const WorkspaceInstructionResponseSchema: z.ZodMiniObject<{
-    resource: z.ZodMiniObject<{
-        resourceId: z.ZodMiniString<string>;
-        name: z.ZodMiniString<string>;
-        version: z.ZodMiniNumberFormat;
-        assetId: z.ZodMiniString<string>;
-        contentHash: z.ZodMiniString<string>;
-        sizeBytes: z.ZodMiniNumberFormat;
-        contentType: z.ZodMiniString<string>;
-        createdAt: z.ZodMiniString<string>;
-        updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        kind: z.ZodMiniLiteral<"instruction">;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export declare const WorkspaceFilePageResponseSchema: z.ZodMiniObject<{
-    resources: z.ZodMiniArray<z.ZodMiniObject<{
-        mountPath: z.ZodMiniString<string>;
-        resourceId: z.ZodMiniString<string>;
-        name: z.ZodMiniString<string>;
-        version: z.ZodMiniNumberFormat;
-        assetId: z.ZodMiniString<string>;
-        contentHash: z.ZodMiniString<string>;
-        sizeBytes: z.ZodMiniNumberFormat;
-        contentType: z.ZodMiniString<string>;
-        createdAt: z.ZodMiniString<string>;
-        updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        kind: z.ZodMiniLiteral<"file">;
-    }, z.core.$strict>>;
-    nextCursor: z.ZodMiniOptional<z.ZodMiniString<string>>;
-}, z.core.$strict>;
-export declare const WorkspaceSkillPageResponseSchema: z.ZodMiniObject<{
-    resources: z.ZodMiniArray<z.ZodMiniObject<{
-        description: z.ZodMiniString<string>;
-        resourceId: z.ZodMiniString<string>;
-        name: z.ZodMiniString<string>;
-        version: z.ZodMiniNumberFormat;
-        assetId: z.ZodMiniString<string>;
-        contentHash: z.ZodMiniString<string>;
-        sizeBytes: z.ZodMiniNumberFormat;
-        contentType: z.ZodMiniString<string>;
-        createdAt: z.ZodMiniString<string>;
-        updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        kind: z.ZodMiniLiteral<"skill">;
-    }, z.core.$strict>>;
-    nextCursor: z.ZodMiniOptional<z.ZodMiniString<string>>;
-}, z.core.$strict>;
-export declare const WorkspaceToolPageResponseSchema: z.ZodMiniObject<{
-    resources: z.ZodMiniArray<z.ZodMiniObject<{
-        description: z.ZodMiniString<string>;
-        entry: z.ZodMiniString<string>;
-        input_schema: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
-        resourceId: z.ZodMiniString<string>;
-        name: z.ZodMiniString<string>;
-        version: z.ZodMiniNumberFormat;
-        assetId: z.ZodMiniString<string>;
-        contentHash: z.ZodMiniString<string>;
-        sizeBytes: z.ZodMiniNumberFormat;
-        contentType: z.ZodMiniString<string>;
-        createdAt: z.ZodMiniString<string>;
-        updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        kind: z.ZodMiniLiteral<"tool">;
-    }, z.core.$strict>>;
-    nextCursor: z.ZodMiniOptional<z.ZodMiniString<string>>;
-}, z.core.$strict>;
-export declare const WorkspaceInstructionPageResponseSchema: z.ZodMiniObject<{
-    resources: z.ZodMiniArray<z.ZodMiniObject<{
-        resourceId: z.ZodMiniString<string>;
-        name: z.ZodMiniString<string>;
-        version: z.ZodMiniNumberFormat;
-        assetId: z.ZodMiniString<string>;
-        contentHash: z.ZodMiniString<string>;
-        sizeBytes: z.ZodMiniNumberFormat;
-        contentType: z.ZodMiniString<string>;
-        createdAt: z.ZodMiniString<string>;
-        updatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        kind: z.ZodMiniLiteral<"instruction">;
-    }, z.core.$strict>>;
-    nextCursor: z.ZodMiniOptional<z.ZodMiniString<string>>;
-}, z.core.$strict>;
-/**
- * `DELETE /workspaces/{workspaceId}` — the owner's GDPR hard-erase.
- *
- * A 200 with counters, not a 204, and idempotent: erasing an absent workspace
- * answers 200 with every counter at zero, indistinguishable from erasing an
- * empty one.
- *
- * This response had no declared client type — `deleteWorkspace()` in
- * `operations.ts` targets the CONTROL plane's `DELETE /api/workspaces/{id}` and
- * returns `void`. Same method, same path pattern, different plane; see the
- * plane-collision note in `testing/response-bindings.ts`. `WorkspaceEraseResult`
- * in `runtime-types.ts` is now `z.infer`red from the schema below, and names the
- * distinction so the two routes are no longer one undifferentiated `void`.
- *
- * `workspaceId` here is the RAW id, not the public `wsp_<hex>` form `whoami` and
- * the MCP-server records carry.
- */
-export declare const WorkspaceEraseResponseSchema: z.ZodMiniObject<{
-    ok: z.ZodMiniLiteral<true>;
-    workspaceId: z.ZodMiniString<string>;
-    erased: z.ZodMiniObject<{
-        workspaceId: z.ZodMiniString<string>;
-        sessionsErased: z.ZodMiniNumberFormat;
-        deletedObjects: z.ZodMiniNumberFormat;
-        deletedConnections: z.ZodMiniNumberFormat;
-        deletedEgressRows: z.ZodMiniNumberFormat;
-        deletedEgressPolicies: z.ZodMiniNumberFormat;
-    }, z.core.$strict>;
-}, z.core.$strict>;

package/dist/_contracts/schemas/response-workspace.js

@@ -1,99 +0,0 @@
-/**
- * Response schemas for the versioned `workspace.*` resource families and for the
- * GDPR workspace erase.
- *
- * The four resource kinds share one server projection (`publicResource`) plus a
- * per-kind metadata spread, so they are built here from one shared shape rather
- * than written out four times. The per-kind extras are exactly the whitelist the
- * publish path stores: `mountPath` for a file, `description` for a skill,
- * `description` + `entry` + `input_schema` for a tool, and nothing at all for an
- * instruction.
- *
- * Divergence from the declared types: `WorkspaceResourceRecordFields` declares
- * `updatedAt?`, and the server projection never emits one. It stays optional
- * here — our own published type permits it, so a deployment that starts sending
- * it is not drift.
- */
-import * as z from "zod/mini";
-import { describeResponse, responseObject, wireLiteral, wireNonEmptyString, wireNonNegativeInteger, wirePositiveInteger, wireString } from "./response-common.js";
-const optional = z.optional;
-/** The nine keys every workspace resource record carries, whatever its kind. */
-const commonResourceShape = {
-    resourceId: wireNonEmptyString,
-    name: wireNonEmptyString,
-    version: wirePositiveInteger,
-    assetId: wireNonEmptyString,
-    contentHash: wireNonEmptyString,
-    sizeBytes: wireNonNegativeInteger,
-    contentType: wireString,
-    createdAt: wireNonEmptyString,
-    updatedAt: optional(wireString)
-};
-export const WorkspaceFileRecordSchema = describeResponse("WorkspaceFileRecord", "An immutable published workspace file version, addressed by asset bytes.", responseObject({
-    kind: wireLiteral("file"),
-    ...commonResourceShape,
-    mountPath: wireNonEmptyString
-}));
-export const WorkspaceSkillRecordSchema = describeResponse("WorkspaceSkillRecord", "An immutable published workspace skill version.", responseObject({
-    kind: wireLiteral("skill"),
-    ...commonResourceShape,
-    description: wireNonEmptyString
-}));
-export const WorkspaceToolRecordSchema = describeResponse("WorkspaceToolRecord", "An immutable published workspace tool version. `input_schema` is the " +
-    "provider-visible JSON Schema object, carried opaquely.", responseObject({
-    kind: wireLiteral("tool"),
-    ...commonResourceShape,
-    description: wireNonEmptyString,
-    entry: wireNonEmptyString,
-    input_schema: z.record(wireString, z.unknown())
-}));
-export const WorkspaceInstructionRecordSchema = describeResponse("WorkspaceInstructionRecord", "An immutable published workspace instruction version. No per-kind extras.", responseObject({
-    kind: wireLiteral("instruction"),
-    ...commonResourceShape
-}));
-function singleResource(record) {
-    return responseObject({ resource: record });
-}
-function resourcePage(record) {
-    return responseObject({
-        resources: z.array(record),
-        nextCursor: optional(wireNonEmptyString)
-    });
-}
-export const WorkspaceFileResponseSchema = describeResponse("WorkspaceFileResponse", "One published workspace file version.", singleResource(WorkspaceFileRecordSchema));
-export const WorkspaceSkillResponseSchema = describeResponse("WorkspaceSkillResponse", "One published workspace skill version.", singleResource(WorkspaceSkillRecordSchema));
-export const WorkspaceToolResponseSchema = describeResponse("WorkspaceToolResponse", "One published workspace tool version.", singleResource(WorkspaceToolRecordSchema));
-export const WorkspaceInstructionResponseSchema = describeResponse("WorkspaceInstructionResponse", "One published workspace instruction version.", singleResource(WorkspaceInstructionRecordSchema));
-export const WorkspaceFilePageResponseSchema = describeResponse("WorkspaceFilePageResponse", "One page of workspace files, ordered by name. `nextCursor` is omitted on the last page.", resourcePage(WorkspaceFileRecordSchema));
-export const WorkspaceSkillPageResponseSchema = describeResponse("WorkspaceSkillPageResponse", "One page of workspace skills, ordered by name.", resourcePage(WorkspaceSkillRecordSchema));
-export const WorkspaceToolPageResponseSchema = describeResponse("WorkspaceToolPageResponse", "One page of workspace tools, ordered by name.", resourcePage(WorkspaceToolRecordSchema));
-export const WorkspaceInstructionPageResponseSchema = describeResponse("WorkspaceInstructionPageResponse", "One page of workspace instructions, ordered by name.", resourcePage(WorkspaceInstructionRecordSchema));
-/**
- * `DELETE /workspaces/{workspaceId}` — the owner's GDPR hard-erase.
- *
- * A 200 with counters, not a 204, and idempotent: erasing an absent workspace
- * answers 200 with every counter at zero, indistinguishable from erasing an
- * empty one.
- *
- * This response had no declared client type — `deleteWorkspace()` in
- * `operations.ts` targets the CONTROL plane's `DELETE /api/workspaces/{id}` and
- * returns `void`. Same method, same path pattern, different plane; see the
- * plane-collision note in `testing/response-bindings.ts`. `WorkspaceEraseResult`
- * in `runtime-types.ts` is now `z.infer`red from the schema below, and names the
- * distinction so the two routes are no longer one undifferentiated `void`.
- *
- * `workspaceId` here is the RAW id, not the public `wsp_<hex>` form `whoami` and
- * the MCP-server records carry.
- */
-export const WorkspaceEraseResponseSchema = describeResponse("WorkspaceEraseResponse", "Counters from a workspace hard-erase. Idempotent: all zero when nothing was there.", responseObject({
-    ok: wireLiteral(true),
-    workspaceId: wireNonEmptyString,
-    erased: responseObject({
-        workspaceId: wireNonEmptyString,
-        sessionsErased: wireNonNegativeInteger,
-        deletedObjects: wireNonNegativeInteger,
-        deletedConnections: wireNonNegativeInteger,
-        deletedEgressRows: wireNonNegativeInteger,
-        deletedEgressPolicies: wireNonNegativeInteger
-    })
-}));

package/dist/_contracts/schemas/runtime-kind.d.ts

@@ -1,31 +0,0 @@
-/**
- * Schema for the managed execution-runtime selector.
- *
- * The token set lives here rather than beside the product documentation in
- * `runtime-kind.ts` for one reason: the schema and the vocabulary must be the
- * same statement. A schema built from a list declared elsewhere would have to
- * import it, and `runtime-kind.ts` already imports this module — a cycle whose
- * evaluation order decides whether the enum sees an initialised list or a
- * temporal-dead-zone error. Declaring the tokens where the schema is built
- * removes the question; `runtime-kind.ts` re-exports them unchanged.
- */
-import * as z from "zod/mini";
-/** The accepted execution-runtime values (the wire/CLI tokens). */
-export declare const RUNTIME_KINDS: readonly ["container", "spot_container", "lambda"];
-/**
- * Wire shape of `runtimeKind`.
- *
- * Omission is the caller's signal to take {@link import("../runtime-kind.js").DEFAULT_RUNTIME_KIND},
- * and it is handled by `parseRuntimeKind` rather than by an `optional()` here:
- * the field is required once present, and a defaulted schema would describe a
- * value the wire never carries.
- *
- * One diagnostic covers every rejection — wrong type, wrong case, unknown token
- * — because that is the only distinction a caller can act on: the message names
- * the whole menu.
- */
-export declare const RuntimeKindSchema: z.ZodMiniEnum<{
-    container: "container";
-    spot_container: "spot_container";
-    lambda: "lambda";
-}>;

package/dist/_contracts/schemas/runtime-kind.js

@@ -1,29 +0,0 @@
-/**
- * Schema for the managed execution-runtime selector.
- *
- * The token set lives here rather than beside the product documentation in
- * `runtime-kind.ts` for one reason: the schema and the vocabulary must be the
- * same statement. A schema built from a list declared elsewhere would have to
- * import it, and `runtime-kind.ts` already imports this module — a cycle whose
- * evaluation order decides whether the enum sees an initialised list or a
- * temporal-dead-zone error. Declaring the tokens where the schema is built
- * removes the question; `runtime-kind.ts` re-exports them unchanged.
- */
-import * as z from "zod/mini";
-/** The accepted execution-runtime values (the wire/CLI tokens). */
-export const RUNTIME_KINDS = ["container", "spot_container", "lambda"];
-/**
- * Wire shape of `runtimeKind`.
- *
- * Omission is the caller's signal to take {@link import("../runtime-kind.js").DEFAULT_RUNTIME_KIND},
- * and it is handled by `parseRuntimeKind` rather than by an `optional()` here:
- * the field is required once present, and a defaulted schema would describe a
- * value the wire never carries.
- *
- * One diagnostic covers every rejection — wrong type, wrong case, unknown token
- * — because that is the only distinction a caller can act on: the message names
- * the whole menu.
- */
-export const RuntimeKindSchema = z.enum(RUNTIME_KINDS, {
-    error: (issue) => `runtimeKind must be one of: ${RUNTIME_KINDS.join(", ")} (got ${JSON.stringify(issue.input)})`
-});

package/dist/_contracts/schemas/runtime-security-profile.d.ts

@@ -1,28 +0,0 @@
-/**
- * Schema for the per-submission security-profile selector.
- *
- * Vocabulary only. What each profile permits — open networking, runtime package
- * installs, customer env vars, MCP servers — is policy evaluated against a
- * submission by `evaluateRuntimeSecurityProfile`, and must not migrate here: a
- * schema that enforced policy would reject a submission for reasons the wire
- * shape cannot express.
- *
- * The token set is declared here, next to the schema built from it, and
- * re-exported by `runtime-security-profile.ts` — see the sibling note in
- * `runtime-kind.ts` for why the constant cannot live on the parser side.
- */
-import * as z from "zod/mini";
-/** The accepted security-profile values (the wire tokens). */
-export declare const RUNTIME_SECURITY_PROFILES: readonly ["strict", "standard", "developer"];
-/**
- * Wire shape of `securityProfile`.
- *
- * Omission (and, for back-compat with records that spelled "unset" as `null`,
- * an explicit null) is handled by `parseRuntimeSecurityProfile`, which resolves
- * it to the `standard` policy rather than to a wire value.
- */
-export declare const RuntimeSecurityProfileSchema: z.ZodMiniEnum<{
-    strict: "strict";
-    standard: "standard";
-    developer: "developer";
-}>;

package/dist/_contracts/schemas/runtime-security-profile.js

@@ -1,26 +0,0 @@
-/**
- * Schema for the per-submission security-profile selector.
- *
- * Vocabulary only. What each profile permits — open networking, runtime package
- * installs, customer env vars, MCP servers — is policy evaluated against a
- * submission by `evaluateRuntimeSecurityProfile`, and must not migrate here: a
- * schema that enforced policy would reject a submission for reasons the wire
- * shape cannot express.
- *
- * The token set is declared here, next to the schema built from it, and
- * re-exported by `runtime-security-profile.ts` — see the sibling note in
- * `runtime-kind.ts` for why the constant cannot live on the parser side.
- */
-import * as z from "zod/mini";
-/** The accepted security-profile values (the wire tokens). */
-export const RUNTIME_SECURITY_PROFILES = ["strict", "standard", "developer"];
-/**
- * Wire shape of `securityProfile`.
- *
- * Omission (and, for back-compat with records that spelled "unset" as `null`,
- * an explicit null) is handled by `parseRuntimeSecurityProfile`, which resolves
- * it to the `standard` policy rather than to a wire value.
- */
-export const RuntimeSecurityProfileSchema = z.enum(RUNTIME_SECURITY_PROFILES, {
-    error: (issue) => `securityProfile must be one of: ${RUNTIME_SECURITY_PROFILES.join(", ")} (got ${JSON.stringify(issue.input)})`
-});

package/dist/_contracts/schemas/runtime-sizes.d.ts

@@ -1,70 +0,0 @@
-/**
- * Schemas for the two sizing-and-lifetime fields a session carries: the
- * `runtimeSize` preset token and the `timeout` duration string.
- *
- * The preset tokens and the accepted-timeout bounds are declared here because
- * they are what the schemas assert; `runtime-sizes.ts` imports this module and
- * re-exports them, so declaring them there instead would be a cycle whose
- * evaluation order decides between an initialised constant and a
- * temporal-dead-zone error. The resource table each token maps to
- * (`RUNTIME_SIZE_PRESETS`) stays on the product side and is proved exhaustive
- * against these tokens at compile time.
- */
-import * as z from "zod/mini";
-/** The accepted runtime-size values (the wire/CLI tokens), ordered as offered. */
-export declare const RUNTIME_SIZES: readonly ["0.25cpu-1gb", "0.5cpu-4gb", "1cpu-6gb", "2cpu-8gb", "4cpu-12gb"];
-/**
- * Wire shape of `runtimeSize`. Omission is handled by `parseRuntimeSize`, which
- * leaves the default to the consumer rather than landing one on the request.
- */
-export declare const RuntimeSizeSchema: 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";
-}>;
-/**
- * Hard ceiling for an explicitly supplied session deadline (8 hours).
- * This bounds accepted customer input and lifetime reasoning; it is not the
- * omission default (`DEFAULT_SESSION_TIMEOUT_MS`) even while both policies
- * currently resolve to eight hours. Bounds on accepted input belong to the
- * schema; the omission default is policy and stays with the resolver.
- */
-export declare const MAX_SESSION_TIMEOUT_MS: number;
-/** Floor on a session deadline (1 minute). */
-export declare const MIN_SESSION_TIMEOUT_MS: number;
-/**
- * A human duration string (`"1h"`, `"90m"`, `"3600s"`, `"500ms"`, or a bare-ms
- * integer).
- *
- * Grammar and magnitude are two checks, not one, because they fail for
- * different reasons and say so: a string that does not match the grammar at all
- * is malformed, while one that matches but names a magnitude too large to be a
- * finite number is a number problem. Both abort so the first failure is the
- * reported one.
- */
-export declare const DurationSchema: z.ZodMiniString<string>;
-/**
- * Convert a validated duration string to whole milliseconds.
- *
- * Deliberately NOT a `.transform()` on {@link DurationSchema}: `z.toJSONSchema(s,
- * {io:"output"})` throws on any transform, which would make the response half of
- * the generated spec ungenerable (L1). Schemas validate; `normalize*()`
- * functions transform. Input is assumed to have passed {@link DurationSchema}.
- */
-export declare function normalizeDurationToMs(duration: string): number;
-/**
- * Wire shape of `timeout` — a duration string, rejected by type before the
- * grammar is consulted so a caller who sent a number learns that first.
- */
-export declare const SessionTimeoutSchema: z.ZodMiniString<string>;
-/**
- * The accepted window for a resolved session deadline.
- *
- * A bound on the decoded milliseconds rather than on the duration string, since
- * `"90m"` and `"5400000"` are the same deadline and must be judged the same
- * way. Invisible in the generated spec (L2) — a JSON Schema for a string cannot
- * state a bound on what the string decodes to — which is why it is named here.
- */
-export declare const SessionTimeoutMsSchema: z.ZodMiniNumber<number>;

package/dist/_contracts/schemas/runtime-sizes.js

@@ -1,127 +0,0 @@
-/**
- * Schemas for the two sizing-and-lifetime fields a session carries: the
- * `runtimeSize` preset token and the `timeout` duration string.
- *
- * The preset tokens and the accepted-timeout bounds are declared here because
- * they are what the schemas assert; `runtime-sizes.ts` imports this module and
- * re-exports them, so declaring them there instead would be a cycle whose
- * evaluation order decides between an initialised constant and a
- * temporal-dead-zone error. The resource table each token maps to
- * (`RUNTIME_SIZE_PRESETS`) stays on the product side and is proved exhaustive
- * against these tokens at compile time.
- */
-import * as z from "zod/mini";
-/** The accepted runtime-size values (the wire/CLI tokens), ordered as offered. */
-export const RUNTIME_SIZES = [
-    "0.25cpu-1gb",
-    "0.5cpu-4gb",
-    "1cpu-6gb",
-    "2cpu-8gb",
-    "4cpu-12gb"
-];
-/**
- * Wire shape of `runtimeSize`. Omission is handled by `parseRuntimeSize`, which
- * leaves the default to the consumer rather than landing one on the request.
- */
-export const RuntimeSizeSchema = z.enum(RUNTIME_SIZES, {
-    error: (issue) => `runtimeSize must be one of: ${RUNTIME_SIZES.join(", ")} (got ${JSON.stringify(issue.input)})`
-});
-// ===========================================================================
-// Session timeout
-// ===========================================================================
-/**
- * Hard ceiling for an explicitly supplied session deadline (8 hours).
- * This bounds accepted customer input and lifetime reasoning; it is not the
- * omission default (`DEFAULT_SESSION_TIMEOUT_MS`) even while both policies
- * currently resolve to eight hours. Bounds on accepted input belong to the
- * schema; the omission default is policy and stays with the resolver.
- */
-export const MAX_SESSION_TIMEOUT_MS = 8 * 60 * 60 * 1000;
-/** Floor on a session deadline (1 minute). */
-export const MIN_SESSION_TIMEOUT_MS = 60 * 1000;
-/**
- * The duration grammar: a non-negative magnitude and an optional unit, where a
- * bare magnitude means milliseconds. Surrounding whitespace is tolerated.
- */
-const DURATION_PATTERN = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/;
-const UNIT_FACTOR_MS = { ms: 1, s: 1_000, m: 60_000, h: 3_600_000 };
-/**
- * The magnitude and unit factor a duration string names, or `undefined` when it
- * does not match the grammar. A bare magnitude means milliseconds.
- */
-function durationParts(value) {
-    const match = DURATION_PATTERN.exec(value.trim());
-    if (match === null) {
-        return undefined;
-    }
-    return {
-        magnitude: Number(match[1]),
-        factorMs: UNIT_FACTOR_MS[(match[2] ?? "ms")]
-    };
-}
-function malformed(input) {
-    return `invalid duration ${JSON.stringify(input)} (expected e.g. "1h", "90m", "30s", "500ms", or a bare ms integer)`;
-}
-/**
- * A human duration string (`"1h"`, `"90m"`, `"3600s"`, `"500ms"`, or a bare-ms
- * integer).
- *
- * Grammar and magnitude are two checks, not one, because they fail for
- * different reasons and say so: a string that does not match the grammar at all
- * is malformed, while one that matches but names a magnitude too large to be a
- * finite number is a number problem. Both abort so the first failure is the
- * reported one.
- */
-export const DurationSchema = z
-    .string({ error: (issue) => malformed(issue.input) })
-    .check(z.refine((value) => durationParts(value) !== undefined, {
-    error: (issue) => malformed(issue.input),
-    abort: true
-}), z.refine((value) => {
-    const parts = durationParts(value);
-    return parts !== undefined && Number.isFinite(parts.magnitude) && parts.magnitude >= 0;
-}, {
-    error: (issue) => `invalid duration ${JSON.stringify(issue.input)} (must be a non-negative number)`,
-    abort: true
-}));
-/**
- * Convert a validated duration string to whole milliseconds.
- *
- * Deliberately NOT a `.transform()` on {@link DurationSchema}: `z.toJSONSchema(s,
- * {io:"output"})` throws on any transform, which would make the response half of
- * the generated spec ungenerable (L1). Schemas validate; `normalize*()`
- * functions transform. Input is assumed to have passed {@link DurationSchema}.
- */
-export function normalizeDurationToMs(duration) {
-    const parts = durationParts(duration);
-    if (parts === undefined) {
-        // Unreachable through `parseDurationToMs`, which validates first. Raising
-        // the schema's own wording rather than returning NaN keeps a direct caller
-        // from propagating a silently bad number, and keeps one statement of the
-        // message.
-        throw new Error(malformed(duration));
-    }
-    return Math.round(parts.magnitude * parts.factorMs);
-}
-/**
- * Wire shape of `timeout` — a duration string, rejected by type before the
- * grammar is consulted so a caller who sent a number learns that first.
- */
-export const SessionTimeoutSchema = z.string({
-    error: (issue) => `timeout must be a duration string (e.g. "1h", "30m"); got ${JSON.stringify(issue.input)}`
-});
-/**
- * The accepted window for a resolved session deadline.
- *
- * A bound on the decoded milliseconds rather than on the duration string, since
- * `"90m"` and `"5400000"` are the same deadline and must be judged the same
- * way. Invisible in the generated spec (L2) — a JSON Schema for a string cannot
- * state a bound on what the string decodes to — which is why it is named here.
- */
-export const SessionTimeoutMsSchema = z.number().check(z.refine((ms) => ms >= MIN_SESSION_TIMEOUT_MS, {
-    error: (issue) => `timeout must be at least ${MIN_SESSION_TIMEOUT_MS}ms (1m); got ${issue.input}ms`,
-    abort: true
-}), z.refine((ms) => ms <= MAX_SESSION_TIMEOUT_MS, {
-    error: (issue) => `timeout must be at most ${MAX_SESSION_TIMEOUT_MS}ms (8h); got ${issue.input}ms`,
-    abort: true
-}));