@aexhq/sdk 0.46.4-canary → 0.50.0

package/dist/_contracts/schemas/asset-bundle.d.ts

@@ -1,70 +0,0 @@
-/**
- * Shape gates for the canonical asset-bundle pipeline.
- *
- * These schemas cover the parts of bundling that are genuinely *shape*
- * questions — is this a files map, is this entry bytes, is this fidelity
- * metadata an object — and stop there. Three kinds of rule deliberately stay in
- * `asset-bundle.ts`:
- *
- * - **Graph rules.** Duplicate paths, an `exec` entry that names no regular
- *   file, a symlink colliding with a leaf, and the leaf-prefix walk are
- *   relations *between* entries. A schema sees one value at a time.
- * - **Accounting.** The cumulative decompressed budget fails on the entry that
- *   crosses it, so it is a fold over the traversal, not a per-value predicate.
- * - **Anything downstream of canonicalisation.** `parseSkillBundleEntry`
- *   normalises a path, and the symlink-target diagnostics quote the *canonical*
- *   path. Per D4 a schema never transforms, so those checks necessarily run
- *   after the normaliser rather than inside a schema.
- *
- * Every factory takes the `kind`/`source` prefix its caller already computed,
- * because the two bundle kinds word the same failure differently ("Skill files
- * map is required" against "Skill bundle exceeds …"), and the fidelity
- * diagnostics are reused verbatim by the restore-side splitter.
- *
- * Nothing here is strict: bundle inputs are open maps keyed by caller-chosen
- * paths, and fidelity metadata must tolerate keys a newer SDK adds.
- */
-import * as z from "zod/mini";
-/**
- * The files map handed to a bundle factory: present, non-empty, within the
- * entry ceiling.
- *
- * Each check aborts, so the ladder reports the same single failure the
- * sequential guard clauses did — a missing map never also reports as empty.
- */
-export declare function bundleFilesMapSchema(kind: string, source: string, maxFiles: number): z.ZodMiniUnknown;
-/**
- * One authored file's contents, before the caller encodes a string to bytes.
- *
- * The encode stays outside: it is a transform, and the original guard tested
- * the coerced value only to catch what was neither a string nor bytes to begin
- * with, which is exactly this union.
- */
-export declare function bundleFileContentsSchema(kind: string, rawPath: string): z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>;
-/** One entry of an already-unzipped archive, which is bytes and never a string. */
-export declare function archiveFileBytesSchema(source: string, rawPath: string): z.ZodMiniCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
-/**
- * The fidelity metadata envelope: an object whose `exec` and `symlinks`, when
- * present, are arrays.
- *
- * Element shape is deliberately `unknown` here. The per-element rules run
- * *after* the entry-count ceilings that sit between this gate and the traversal,
- * and reporting an element failure ahead of a count failure would invert the
- * order the guard clauses established.
- */
-export declare function bundleFidelityMetaSchema(source: string): z.ZodMiniObject<{
-    exec: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnknown>>;
-    symlinks: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniUnknown>>;
-}, z.core.$strip>;
-/**
- * One `symlinks` element, checked for object-ness only.
- *
- * Its `path` and `target` are validated by the two schemas below, in the order
- * canonicalisation forces: the target diagnostics quote the canonical path, so
- * the path must be normalised before the target can be described.
- */
-export declare function bundleSymlinkRecordSchema(source: string): z.ZodMiniObject<{}, z.core.$strip>;
-/** A fidelity metadata path as supplied, before canonicalisation. */
-export declare function bundleMetadataPathSchema(source: string, kind: "executable" | "symlink"): z.ZodMiniString<string>;
-/** A captured symlink target, reported against the canonical link path. */
-export declare function bundleSymlinkTargetSchema(source: string, path: string, maxLength: number): z.ZodMiniString<string>;

package/dist/_contracts/schemas/asset-bundle.js

@@ -1,107 +0,0 @@
-/**
- * Shape gates for the canonical asset-bundle pipeline.
- *
- * These schemas cover the parts of bundling that are genuinely *shape*
- * questions — is this a files map, is this entry bytes, is this fidelity
- * metadata an object — and stop there. Three kinds of rule deliberately stay in
- * `asset-bundle.ts`:
- *
- * - **Graph rules.** Duplicate paths, an `exec` entry that names no regular
- *   file, a symlink colliding with a leaf, and the leaf-prefix walk are
- *   relations *between* entries. A schema sees one value at a time.
- * - **Accounting.** The cumulative decompressed budget fails on the entry that
- *   crosses it, so it is a fold over the traversal, not a per-value predicate.
- * - **Anything downstream of canonicalisation.** `parseSkillBundleEntry`
- *   normalises a path, and the symlink-target diagnostics quote the *canonical*
- *   path. Per D4 a schema never transforms, so those checks necessarily run
- *   after the normaliser rather than inside a schema.
- *
- * Every factory takes the `kind`/`source` prefix its caller already computed,
- * because the two bundle kinds word the same failure differently ("Skill files
- * map is required" against "Skill bundle exceeds …"), and the fidelity
- * diagnostics are reused verbatim by the restore-side splitter.
- *
- * Nothing here is strict: bundle inputs are open maps keyed by caller-chosen
- * paths, and fidelity metadata must tolerate keys a newer SDK adds.
- */
-import * as z from "zod/mini";
-/** Count the own enumerable keys of an already-validated map-shaped value. */
-function keyCount(value) {
-    return Object.keys(value).length;
-}
-/**
- * The files map handed to a bundle factory: present, non-empty, within the
- * entry ceiling.
- *
- * Each check aborts, so the ladder reports the same single failure the
- * sequential guard clauses did — a missing map never also reports as empty.
- */
-export function bundleFilesMapSchema(kind, source, maxFiles) {
-    return z.unknown().check(z.refine((value) => Boolean(value) && typeof value === "object", {
-        error: `${kind} files map is required`,
-        abort: true
-    }), z.refine((value) => keyCount(value) > 0, {
-        error: `${kind} files map cannot be empty`,
-        abort: true
-    }), z.refine((value) => keyCount(value) <= maxFiles, {
-        error: (issue) => `${source} exceeds ${maxFiles} file limit (got ${keyCount(issue.input)})`,
-        abort: true
-    }));
-}
-/**
- * One authored file's contents, before the caller encodes a string to bytes.
- *
- * The encode stays outside: it is a transform, and the original guard tested
- * the coerced value only to catch what was neither a string nor bytes to begin
- * with, which is exactly this union.
- */
-export function bundleFileContentsSchema(kind, rawPath) {
-    return z.union([z.string(), z.instanceof(Uint8Array)], {
-        error: `${kind} file "${rawPath}" must be a string or Uint8Array`
-    });
-}
-/** One entry of an already-unzipped archive, which is bytes and never a string. */
-export function archiveFileBytesSchema(source, rawPath) {
-    return z.instanceof(Uint8Array, {
-        error: `${source} file ${JSON.stringify(rawPath)} must be a Uint8Array`
-    });
-}
-/**
- * The fidelity metadata envelope: an object whose `exec` and `symlinks`, when
- * present, are arrays.
- *
- * Element shape is deliberately `unknown` here. The per-element rules run
- * *after* the entry-count ceilings that sit between this gate and the traversal,
- * and reporting an element failure ahead of a count failure would invert the
- * order the guard clauses established.
- */
-export function bundleFidelityMetaSchema(source) {
-    return z.object({
-        exec: z.optional(z.array(z.unknown(), { error: `${source} fidelity metadata exec must be an array` })),
-        symlinks: z.optional(z.array(z.unknown(), { error: `${source} fidelity metadata symlinks must be an array` }))
-    }, { error: `${source} fidelity metadata must be an object` });
-}
-/**
- * One `symlinks` element, checked for object-ness only.
- *
- * Its `path` and `target` are validated by the two schemas below, in the order
- * canonicalisation forces: the target diagnostics quote the canonical path, so
- * the path must be normalised before the target can be described.
- */
-export function bundleSymlinkRecordSchema(source) {
-    return z.object({}, { error: `${source} fidelity metadata contains a malformed symlink` });
-}
-/** A fidelity metadata path as supplied, before canonicalisation. */
-export function bundleMetadataPathSchema(source, kind) {
-    const message = `${source} ${kind} path must be a non-empty string`;
-    return z.string({ error: message }).check(z.minLength(1, { error: message, abort: true }));
-}
-/** A captured symlink target, reported against the canonical link path. */
-export function bundleSymlinkTargetSchema(source, path, maxLength) {
-    return z
-        .string({ error: `${source} symlink ${JSON.stringify(path)} target must be a string` })
-        .check(z.maxLength(maxLength, {
-        error: `${source} symlink ${JSON.stringify(path)} target exceeds ${maxLength} characters`,
-        abort: true
-    }));
-}

package/dist/_contracts/schemas/asset-ref.d.ts

@@ -1,61 +0,0 @@
-/**
- * Schemas for the storage-neutral uploaded-asset wire reference and the
- * container directory it unzips into.
- *
- * The id pattern, the mount-path pattern and the mount-path assert are declared
- * here, next to the schema that enforces them, and re-exported by
- * `session-config.ts` under their published names — same reason as the sibling
- * vocabularies: the parser module imports this one, so the constants cannot live
- * there without a cycle.
- */
-import * as z from "zod/mini";
-import type { AssetRef } from "../session-config.js";
-/**
- * Asset ids are storage-neutral product ids. Current uploads derive the id from
- * the content digest (`asset_<sha256hex>`), but callers must treat it as opaque.
- */
-export declare const ASSET_ID_PATTERN: RegExp;
-/**
- * A `mountPath` is an ABSOLUTE container directory under the workspace. It must
- * start with `/`, contain no `..`/`.` traversal or NUL/backslash, and stay
- * within {@link MOUNT_PATH_MAX_LENGTH}. The managed runtime rebases it under the
- * workspace root, so a path outside `/workspace` is clamped there — the pattern
- * just rejects obviously-malformed input at the SDK/BFF boundary. A trailing
- * slash is allowed (it is a directory) but not required.
- */
-export declare const MOUNT_PATH_PATTERN: RegExp;
-export declare const MOUNT_PATH_MAX_LENGTH = 512;
-/**
- * Validate a `File.mountPath` (an absolute container directory). Shared by the
- * SDK `File` builders and the BFF asset-ref parser so both reject the same
- * malformed input. Throws with `field` context on failure.
- *
- * Kept as an assert rather than folded into {@link mountPath}: the SDK `File`
- * builders and the workspace-resource parsers call it directly on a value they
- * already hold, with their own field name, and never through a schema.
- */
-export declare function assertValidMountPath(value: string, field: string): void;
-/**
- * Wire shape of any `kind: "asset"` ref (file / tool bundle), mounted at `path`.
- *
- * Declaration order is the order the checks report in, matching the sequential
- * assetId/name/mountPath ladder this replaces. Built per path rather than
- * memoised because callers mount it at indexed positions.
- */
-export declare function assetRefSchema(path: string): z.ZodMiniObject<{
-    kind: z.ZodMiniOptional<z.ZodMiniLiteral<"asset">>;
-    assetId: z.ZodMiniString<string>;
-    name: z.ZodMiniString<string>;
-    mountPath: z.ZodMiniOptional<z.ZodMiniString<string>>;
-}, z.core.$strict>;
-export type AssetRefWire = z.infer<ReturnType<typeof assetRefSchema>>;
-/** Validate an asset ref mounted at `path`, in the family's own words. */
-export declare function parseAssetRefWire(record: unknown, path: string): AssetRefWire;
-/**
- * Stamp the discriminator and drop an absent `mountPath`.
- *
- * Separate from the schema per D4: `z.toJSONSchema(s, {io:"output"})` throws on
- * any `.transform()`, which would make the response half of the generated spec
- * ungenerable. Schemas validate; `normalize*()` functions transform.
- */
-export declare function normalizeAssetRef(wire: AssetRefWire): AssetRef;

package/dist/_contracts/schemas/asset-ref.js

@@ -1,118 +0,0 @@
-/**
- * Schemas for the storage-neutral uploaded-asset wire reference and the
- * container directory it unzips into.
- *
- * The id pattern, the mount-path pattern and the mount-path assert are declared
- * here, next to the schema that enforces them, and re-exported by
- * `session-config.ts` under their published names — same reason as the sibling
- * vocabularies: the parser module imports this one, so the constants cannot live
- * there without a cycle.
- */
-import * as z from "zod/mini";
-import { parseWire, wireObject } from "./wire.js";
-/**
- * Asset ids are storage-neutral product ids. Current uploads derive the id from
- * the content digest (`asset_<sha256hex>`), but callers must treat it as opaque.
- */
-export const ASSET_ID_PATTERN = /^asset_[A-Za-z0-9_-]{8,128}$/;
-/**
- * A `mountPath` is an ABSOLUTE container directory under the workspace. It must
- * start with `/`, contain no `..`/`.` traversal or NUL/backslash, and stay
- * within {@link MOUNT_PATH_MAX_LENGTH}. The managed runtime rebases it under the
- * workspace root, so a path outside `/workspace` is clamped there — the pattern
- * just rejects obviously-malformed input at the SDK/BFF boundary. A trailing
- * slash is allowed (it is a directory) but not required.
- */
-export const MOUNT_PATH_PATTERN = /^\/(?:[^/\0\\]+\/?)*$/;
-export const MOUNT_PATH_MAX_LENGTH = 512;
-/**
- * Validate a `File.mountPath` (an absolute container directory). Shared by the
- * SDK `File` builders and the BFF asset-ref parser so both reject the same
- * malformed input. Throws with `field` context on failure.
- *
- * Kept as an assert rather than folded into {@link mountPath}: the SDK `File`
- * builders and the workspace-resource parsers call it directly on a value they
- * already hold, with their own field name, and never through a schema.
- */
-export function assertValidMountPath(value, field) {
-    if (value.length === 0 || value.length > MOUNT_PATH_MAX_LENGTH) {
-        throw new Error(`${field} must be 1..${MOUNT_PATH_MAX_LENGTH} chars`);
-    }
-    if (!value.startsWith("/")) {
-        throw new Error(`${field} must be an absolute path starting with '/'`);
-    }
-    if (value.includes("\0") || value.includes("\\")) {
-        throw new Error(`${field} must not contain NUL or backslash`);
-    }
-    if (value.split("/").some((seg) => seg === "..")) {
-        throw new Error(`${field} must not contain '..' traversal segments`);
-    }
-    if (!MOUNT_PATH_PATTERN.test(value)) {
-        throw new Error(`${field} must match ${MOUNT_PATH_PATTERN.source}`);
-    }
-}
-/**
- * {@link assertValidMountPath} reused as both the verdict and the wording of a
- * schema check, so the five-rung ladder is stated once.
- */
-function mountPathFailure(value, field) {
-    try {
-        assertValidMountPath(value, field);
-        return null;
-    }
-    catch (error) {
-        return error.message;
-    }
-}
-/** An optional absolute container directory, reported under `field`. */
-function mountPath(field) {
-    return z.optional(z.string({ error: `${field}, when provided, must be a string` }).check(z.refine((value) => mountPathFailure(value, field) === null, {
-        error: (issue) => mountPathFailure(issue.input, field) ?? "",
-        abort: true
-    })));
-}
-/**
- * Wire shape of any `kind: "asset"` ref (file / tool bundle), mounted at `path`.
- *
- * Declaration order is the order the checks report in, matching the sequential
- * assetId/name/mountPath ladder this replaces. Built per path rather than
- * memoised because callers mount it at indexed positions.
- */
-export function assetRefSchema(path) {
-    const assetId = `${path}.assetId must match ${ASSET_ID_PATTERN.source}`;
-    const name = `${path}.name must be a non-empty string (<= 128 chars)`;
-    return wireObject(path, {
-        // Optional, because the normaliser stamps `kind: "asset"` on the way out
-        // and a caller that omits it is complete. Not unread, though: `AssetRef`
-        // declares `kind: "asset"` and nothing else, so a ref labelled anything
-        // else is a caller mistake and is now told so rather than silently
-        // relabelled.
-        kind: z.optional(z.literal("asset", { error: `${path}.kind, when provided, must be "asset"` })),
-        assetId: z.string({ error: assetId }).check(z.regex(ASSET_ID_PATTERN, { error: assetId })),
-        name: z
-            .string({ error: name })
-            .check(z.minLength(1, { error: name }), z.maxLength(128, { error: name })),
-        mountPath: mountPath(`${path}.mountPath`)
-    }, {
-        unknownKey: (objectPath, key) => `${objectPath} contains unexpected field for asset ref: ${key}`
-    });
-}
-/** Validate an asset ref mounted at `path`, in the family's own words. */
-export function parseAssetRefWire(record, path) {
-    return parseWire(assetRefSchema(path), record);
-}
-/**
- * Stamp the discriminator and drop an absent `mountPath`.
- *
- * Separate from the schema per D4: `z.toJSONSchema(s, {io:"output"})` throws on
- * any `.transform()`, which would make the response half of the generated spec
- * ungenerable. Schemas validate; `normalize*()` functions transform.
- */
-export function normalizeAssetRef(wire) {
-    return {
-        kind: "asset",
-        assetId: wire.assetId,
-        name: wire.name,
-        ...(wire.mountPath !== undefined ? { mountPath: wire.mountPath } : {})
-    };
-}

package/dist/_contracts/schemas/bundle-manifest.d.ts

@@ -1,66 +0,0 @@
-/**
- * Schemas for the `.aexmeta.json` bundle fidelity sidecar.
- *
- * Two schemas, because the sidecar is read under different rules than it is
- * written:
- *
- * - {@link bundleManifestSidecarSchema} gates bytes that arrived from an
- *   untrusted zip. It carries **no messages**: `tryParseBundleManifest` reports
- *   a rejected sidecar as `null`, never as a thrown diagnostic, and a message no
- *   caller can observe is a message that will drift.
- * - {@link serializableBundleManifestSchema} gates a manifest on its way out and
- *   *does* throw, so it states exactly the two limits the serializer already
- *   enforced and nothing more. It deliberately does not re-validate the shape:
- *   its input is `BundleManifest`, and widening an output guard into a full
- *   structural check would reject values the type system already admitted.
- *
- * Both are factories over their limits rather than importers of them, so
- * `bundle-manifest.ts` stays the single site that decides what the caps are and
- * this module stays free of a cycle back into it.
- *
- * Neither schema is strict. An unknown key in a sidecar written by a newer SDK
- * must be ignored, not rejected — that forward-compatibility is the whole point
- * of the `v` field.
- */
-import * as z from "zod/mini";
-/**
- * A v1 sidecar: `exec` paths and `symlinks` leaves, each array bounded before
- * the graph that consumes it is built.
- *
- * An unknown `v` fails the literal and therefore yields `null`, which is the
- * forward-compatible outcome: metadata is dropped and the restore proceeds
- * content-only.
- */
-export declare function bundleManifestSidecarSchema(maxRecords: number, maxSymlinkTargetLength: number): z.ZodMiniObject<{
-    v: z.ZodMiniLiteral<1>;
-    exec: z.ZodMiniArray<z.ZodMiniString<string>>;
-    symlinks: z.ZodMiniArray<z.ZodMiniObject<{
-        path: z.ZodMiniString<string>;
-        target: z.ZodMiniString<string>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type BundleManifestSidecarSchema = ReturnType<typeof bundleManifestSidecarSchema>;
-export type BundleManifestSidecar = z.infer<BundleManifestSidecarSchema>;
-/**
- * Parse a decoded sidecar value, collapsing every rejection to `null`.
- *
- * The `null`-returning counterpart to `parseWire`. It lives here rather than in
- * `wire.ts` because a nullable outcome is this family's convention, not the
- * package's: every other wire parser throws.
- */
-export declare function tryParseBundleManifestSidecar(schema: BundleManifestSidecarSchema, value: unknown): BundleManifestSidecar | null;
-/**
- * The two limits `serializeBundleManifest` refuses to encode past.
- *
- * Both arrays share the record-limit wording, and `exec` is declared first, so
- * the shallowest-issue rule in `errorFromZod` reproduces the original
- * `exec.length > max || symlinks.length > max` short-circuit. A too-long target
- * sits two levels deeper and therefore still loses to either record limit,
- * matching the order the guard clauses ran in.
- */
-export declare function serializableBundleManifestSchema(maxRecords: number, maxSymlinkTargetLength: number): z.ZodMiniObject<{
-    exec: z.ZodMiniArray<z.ZodMiniUnknown>;
-    symlinks: z.ZodMiniArray<z.ZodMiniObject<{
-        target: z.ZodMiniString<string>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;

package/dist/_contracts/schemas/bundle-manifest.js

@@ -1,77 +0,0 @@
-/**
- * Schemas for the `.aexmeta.json` bundle fidelity sidecar.
- *
- * Two schemas, because the sidecar is read under different rules than it is
- * written:
- *
- * - {@link bundleManifestSidecarSchema} gates bytes that arrived from an
- *   untrusted zip. It carries **no messages**: `tryParseBundleManifest` reports
- *   a rejected sidecar as `null`, never as a thrown diagnostic, and a message no
- *   caller can observe is a message that will drift.
- * - {@link serializableBundleManifestSchema} gates a manifest on its way out and
- *   *does* throw, so it states exactly the two limits the serializer already
- *   enforced and nothing more. It deliberately does not re-validate the shape:
- *   its input is `BundleManifest`, and widening an output guard into a full
- *   structural check would reject values the type system already admitted.
- *
- * Both are factories over their limits rather than importers of them, so
- * `bundle-manifest.ts` stays the single site that decides what the caps are and
- * this module stays free of a cycle back into it.
- *
- * Neither schema is strict. An unknown key in a sidecar written by a newer SDK
- * must be ignored, not rejected — that forward-compatibility is the whole point
- * of the `v` field.
- */
-import * as z from "zod/mini";
-/**
- * A v1 sidecar: `exec` paths and `symlinks` leaves, each array bounded before
- * the graph that consumes it is built.
- *
- * An unknown `v` fails the literal and therefore yields `null`, which is the
- * forward-compatible outcome: metadata is dropped and the restore proceeds
- * content-only.
- */
-export function bundleManifestSidecarSchema(maxRecords, maxSymlinkTargetLength) {
-    return z.object({
-        v: z.literal(1),
-        exec: z.array(z.string().check(z.minLength(1))).check(z.maxLength(maxRecords)),
-        symlinks: z
-            .array(z.object({
-            path: z.string().check(z.minLength(1)),
-            target: z.string().check(z.maxLength(maxSymlinkTargetLength))
-        }))
-            .check(z.maxLength(maxRecords))
-    });
-}
-/**
- * Parse a decoded sidecar value, collapsing every rejection to `null`.
- *
- * The `null`-returning counterpart to `parseWire`. It lives here rather than in
- * `wire.ts` because a nullable outcome is this family's convention, not the
- * package's: every other wire parser throws.
- */
-export function tryParseBundleManifestSidecar(schema, value) {
-    const result = z.safeParse(schema, value);
-    return result.success ? result.data : null;
-}
-/**
- * The two limits `serializeBundleManifest` refuses to encode past.
- *
- * Both arrays share the record-limit wording, and `exec` is declared first, so
- * the shallowest-issue rule in `errorFromZod` reproduces the original
- * `exec.length > max || symlinks.length > max` short-circuit. A too-long target
- * sits two levels deeper and therefore still loses to either record limit,
- * matching the order the guard clauses ran in.
- */
-export function serializableBundleManifestSchema(maxRecords, maxSymlinkTargetLength) {
-    const recordLimit = `bundle fidelity metadata exceeds the ${maxRecords}-record limit`;
-    const targetLimit = `bundle fidelity symlink target exceeds ${maxSymlinkTargetLength} characters`;
-    return z.object({
-        exec: z.array(z.unknown()).check(z.maxLength(maxRecords, { error: recordLimit })),
-        symlinks: z
-            .array(z.object({
-            target: z.string().check(z.maxLength(maxSymlinkTargetLength, { error: targetLimit }))
-        }))
-            .check(z.maxLength(maxRecords, { error: recordLimit }))
-    });
-}

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

@@ -1,32 +0,0 @@
-/**
- * Wire schemas, published as the supported validation surface.
- *
- * **Depend on `~standard`, not on Zod.** Every schema here implements
- * [Standard Schema](https://standardschema.dev) v1, so a consumer can validate
- * against it without importing — or agreeing with — our schema library:
- *
- * ```ts
- * import { SessionWebhookSchema } from "@aexhq/contracts";
- *
- * const result = await SessionWebhookSchema["~standard"].validate(input);
- * if (result.issues) { /* … *\/ }
- * ```
- *
- * That indirection is what keeps the choice of Zod reversible: if it is ever
- * replaced, the published interface does not move — only what sits behind
- * `~standard` does.
- *
- * These schemas follow the same semver contract as the exported types: widening
- * one is a minor, tightening one is a breaking change.
- *
- * Note for tooling authors: `~standard.jsonSchema` is **absent** here. These are
- * `zod/mini` schemas and the JSON Schema converter is tree-shaken out of that
- * entrypoint. JSON Schema conversion is a build-time concern — the OpenAPI
- * generator imports full `zod` off these same objects, which works because both
- * entrypoints construct the same core classes.
- */
-export { SessionWebhookSchema } from "./session-webhook.js";
-export { SessionLimitsSchema, normalizeSessionLimits } from "./session-limits.js";
-export type { SessionLimitsWire } from "./session-limits.js";
-export { SessionMachineSchema, normalizeSessionMachine } from "./session-machine.js";
-export type { SessionMachineWire } from "./session-machine.js";

package/dist/_contracts/schemas/index.js

@@ -1,30 +0,0 @@
-/**
- * Wire schemas, published as the supported validation surface.
- *
- * **Depend on `~standard`, not on Zod.** Every schema here implements
- * [Standard Schema](https://standardschema.dev) v1, so a consumer can validate
- * against it without importing — or agreeing with — our schema library:
- *
- * ```ts
- * import { SessionWebhookSchema } from "@aexhq/contracts";
- *
- * const result = await SessionWebhookSchema["~standard"].validate(input);
- * if (result.issues) { /* … *\/ }
- * ```
- *
- * That indirection is what keeps the choice of Zod reversible: if it is ever
- * replaced, the published interface does not move — only what sits behind
- * `~standard` does.
- *
- * These schemas follow the same semver contract as the exported types: widening
- * one is a minor, tightening one is a breaking change.
- *
- * Note for tooling authors: `~standard.jsonSchema` is **absent** here. These are
- * `zod/mini` schemas and the JSON Schema converter is tree-shaken out of that
- * entrypoint. JSON Schema conversion is a build-time concern — the OpenAPI
- * generator imports full `zod` off these same objects, which works because both
- * entrypoints construct the same core classes.
- */
-export { SessionWebhookSchema } from "./session-webhook.js";
-export { SessionLimitsSchema, normalizeSessionLimits } from "./session-limits.js";
-export { SessionMachineSchema, normalizeSessionMachine } from "./session-machine.js";

package/dist/_contracts/schemas/mcp-server.d.ts

@@ -1,99 +0,0 @@
-/**
- * Schemas for the two MCP server declarations on the request side: the
- * non-secret `McpServerRef` that enters the hashed submission, and the
- * `SessionConfigMcpServer` a `session.json` may carry with inline `headers`.
- *
- * Two rules are DEFERRED BACK to `session-config.ts` through {@link McpWirePolicy}
- * rather than moved here, and that is deliberate:
- * `scripts/cicd/check-parser-ratchet.mjs`'s sibling gate
- * `scripts/cicd/check-contract-parity.mjs` locates the SSRF host deny-list
- * inside `session-config.ts` — it slices the file from `denyReasonForHostIp` to
- * `parseRemoteMcpTransport` and byte-compares that region against
- * `platform/packages/shared/src/blueprint.ts`. Moving either function here would
- * break the only cross-repo check that keeps the two deny-lists identical, so
- * the schema takes them as parameters instead.
- */
-import * as z from "zod/mini";
-import type { McpServerRef, RemoteMcpTransport, SessionConfigMcpServer } from "../session-config.js";
-export declare const MCP_SERVER_NAME_PATTERN: RegExp;
-/**
- * Canonical error string for any attempt to declare a stdio-shaped MCP
- * server (`transport: "stdio"`, or a stdio-only field like `command` /
- * `args` / `env`). Pinned in source so every surface — shared parser,
- * SDK builder, CLI flag parser, dashboard form — surfaces the same
- * message and a user can find it via grep.
- */
-export declare const REMOTE_MCP_STDIO_REJECTED_MESSAGE = "stdio MCP servers are not supported by Aex. Aex supports remote MCP servers over HTTP/SSE only.";
-/**
- * The host and transport rules the MCP schemas defer to.
- *
- * See the module header for why these are injected rather than imported.
- */
-export interface McpWirePolicy {
-    /** Reason this URL's host must be refused, or `null` when it is acceptable. */
-    readonly denyReasonForHost: (url: URL) => string | null;
-    /** Throws when `input` is neither absent nor a supported remote transport. */
-    readonly parseTransport: (input: unknown, field: string) => RemoteMcpTransport | undefined;
-}
-/**
- * A remote-only precondition on any MCP declaration, whatever else is wrong
- * with it.
- *
- * Deliberately its own schema, parsed BEFORE the strict object rather than
- * carried on it as a `.check()`. Zod raises `unrecognized_keys` while parsing
- * the object body and skips the object's own checks once the body has issues
- * (measured), and `errorFromZod` ranks a rejected key ahead of every other issue
- * at the same depth — so no rule expressed on the object can outrank an unknown
- * key. `{ command: "local", unknown: true }` must report stdio, not `unknown`,
- * which is exactly the sequencing the hand-written parser had: reject the stdio
- * shape, then apply the allow-list.
- */
-export declare const RemoteMcpShapeSchema: z.ZodMiniUnknown;
-/**
- * Throw the canonical stdio-rejected error if the record carries any
- * stdio-only marker (`transport: "stdio"`, `command`, `args`, `env`).
- * Used by both the shared parser and the SDK `McpServer.remote`
- * builder so every entry point surfaces the same message.
- */
-export declare function rejectStdioMcpShape(record: Record<string, unknown>): void;
-/**
- * Wire shape of the NON-SECRET half of an MCP server declaration.
- *
- * Headers belong on `SessionConfigMcpServer`, and the wire
- * `submission.mcpServers` must NEVER contain them, so anything other than
- * `{name, url, transport}` is rejected explicitly — a caller accidentally
- * inlining `headers` into the non-secret half fails loudly instead of having the
- * field silently dropped.
- */
-export declare function mcpServerRefSchema(path: string, policy: McpWirePolicy): z.ZodMiniObject<{
-    name: z.ZodMiniString<string>;
-    url: z.ZodMiniString<string>;
-    transport: z.ZodMiniOptional<z.ZodMiniUnknown>;
-}, z.core.$strict>;
-/**
- * Wire shape of a session-config MCP entry: the non-secret ref plus the inline
- * `headers` the SDK splits out at submission time, so config loaded from
- * `--config session.json` cannot smuggle unrelated fields past the parser.
- */
-export declare function sessionConfigMcpServerSchema(path: string, policy: McpWirePolicy): z.ZodMiniObject<{
-    name: z.ZodMiniString<string>;
-    url: z.ZodMiniString<string>;
-    transport: z.ZodMiniOptional<z.ZodMiniUnknown>;
-    headers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
-}, z.core.$strict>;
-export type McpServerRefWire = z.infer<ReturnType<typeof mcpServerRefSchema>>;
-export type SessionConfigMcpServerWire = z.infer<ReturnType<typeof sessionConfigMcpServerSchema>>;
-/** Reject a stdio shape, then validate the non-secret ref mounted at `path`. */
-export declare function parseMcpServerRefWire(input: unknown, path: string, policy: McpWirePolicy): McpServerRefWire;
-/** Reject a stdio shape, then validate a session-config entry mounted at `path`. */
-export declare function parseSessionConfigMcpServerWire(input: unknown, path: string, policy: McpWirePolicy): SessionConfigMcpServerWire;
-/**
- * Drop an absent `transport` so an omitted field never lands as an explicit
- * `undefined` on the hashed payload.
- *
- * Separate from the schema per D4 — see
- * {@link import("./asset-ref.js").normalizeAssetRef}.
- */
-export declare function normalizeMcpServerRef(wire: McpServerRefWire): McpServerRef;
-/** As {@link normalizeMcpServerRef}, preserving inline `headers` when supplied. */
-export declare function normalizeSessionConfigMcpServer(wire: SessionConfigMcpServerWire): SessionConfigMcpServer;