@aexhq/sdk 0.46.5-canary → 0.51.0

package/dist/_contracts/asset-upload-helper.js

@@ -1,84 +0,0 @@
-import { extractErrorCode, redactUrl } from "./sdk-errors.js";
-import { isRetryableHttpStatus, tryParseRetryAfterMs } from "./retry-core.js";
-import { nextHttpRetryDelayMs, resolveHttpRetryDeps, resolveHttpRetryPolicy } from "./http.js";
-export async function putDirectUploadWithRetry(fetchImpl, uploadUrl, init, options = {}) {
-    const policy = resolveHttpRetryPolicy(options);
-    const deps = resolveHttpRetryDeps(options);
-    const startedAtMs = deps.now();
-    for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
-        let response;
-        try {
-            response = await fetchImpl(uploadUrl, init);
-        }
-        catch (err) {
-            const delayMs = isRetryableUploadError(err)
-                ? nextHttpRetryDelayMs({ policy, attempt, startedAtMs, deps })
-                : undefined;
-            if (delayMs === undefined)
-                throw directUploadNetworkError(uploadUrl, err, attempt);
-            await deps.sleep(delayMs, init.signal ?? undefined);
-            continue;
-        }
-        if (response.ok)
-            return;
-        const retryAfterMs = tryParseRetryAfterMs(response.headers?.get("retry-after"), deps.now());
-        const delayMs = isRetryableUploadStatus(response.status)
-            ? nextHttpRetryDelayMs({ policy, attempt, startedAtMs, deps, retryAfterMs })
-            : undefined;
-        if (delayMs !== undefined) {
-            await response.text().catch(() => "");
-            await deps.sleep(delayMs, init.signal ?? undefined);
-            continue;
-        }
-        const detail = await response.text().catch(() => "");
-        throw directUploadResponseError(uploadUrl, response.status, detail, attempt);
-    }
-}
-/**
- * Object-store PUT retry set: the shared HTTP set from `retry-core.ts`, widened
- * by the two statuses only a storage endpoint emits (408 Request Timeout, 425
- * Too Early) plus the remaining 5xx an S3-compatible endpoint can return.
- */
-export function isRetryableUploadStatus(status) {
-    return isRetryableHttpStatus(status) || status === 408 || status === 425 || (status >= 500 && status <= 599);
-}
-/** Every transport rejection except a caller-initiated abort is transient for a PUT. */
-export function isRetryableUploadError(err) {
-    return err?.name !== "AbortError";
-}
-export function directUploadNetworkError(uploadUrl, err, attempts) {
-    const safeUrl = redactUrl(uploadUrl);
-    const code = extractErrorCode(err);
-    const detail = sanitizeUploadText(errorMessage(err)).slice(0, 500);
-    return new Error(`uploadAsset: direct upload PUT failed for ${safeUrl} after ${attemptsLabel(attempts)}` +
-        (code ? ` (${code})` : "") +
-        (detail ? `: ${detail}` : ""));
-}
-export function directUploadResponseError(uploadUrl, status, detail, attempts) {
-    const safeUrl = redactUrl(uploadUrl);
-    const safeDetail = sanitizeUploadText(detail).slice(0, 500);
-    return new Error(`uploadAsset: direct upload PUT failed for ${safeUrl} with status ${status}` +
-        (attempts > 1 ? ` after ${attemptsLabel(attempts)}` : "") +
-        (safeDetail ? `: ${safeDetail}` : ""));
-}
-export function sanitizeUploadText(text) {
-    return text
-        .replace(/https?:\/\/[^\s<>"'`]+/g, (raw) => redactUrlPreservingTrailingPunctuation(raw))
-        .replace(/\b(?:X-Amz-(?:Algorithm|Credential|Date|Expires|Security-Token|Signature|SignedHeaders)|AWSAccessKeyId|Signature|Credential|Security-Token|AccessKeyId|SecretAccessKey|SessionToken)=([^&\s<>"'`]+)/gi, "[redacted]")
-        .replace(/\bAKIA[0-9A-Z]{8,}\b/g, "[redacted]");
-}
-function attemptsLabel(attempts) {
-    return attempts === 1 ? "1 attempt" : `${attempts} attempts`;
-}
-function errorMessage(err) {
-    if (err instanceof Error)
-        return err.message || err.name;
-    if (typeof err === "string")
-        return err;
-    return String(err);
-}
-function redactUrlPreservingTrailingPunctuation(raw) {
-    const trailing = raw.match(/[),.;:!?]+$/)?.[0] ?? "";
-    const candidate = trailing ? raw.slice(0, -trailing.length) : raw;
-    return `${redactUrl(candidate)}${trailing}`;
-}

package/dist/_contracts/billing-admission.d.ts

@@ -1,29 +0,0 @@
-/**
- * The admission vocabulary the money gates decide with.
- *
- * A LEAF module, importing nothing, for the same reason `schemas/runtime-kind.ts`
- * is one: four modules need this list — `runtime-types.ts` for `WhoAmI.limits`,
- * `account-types.ts` for `BillingSummary`, and the two response schemas that
- * check both against the wire — and any of them owning it would make the other
- * three import a much larger module for one constant, or force a cycle between a
- * schema and the types derived from it.
- *
- * Contrast an allowance `dimension`, which is deliberately an OPEN string: the
- * dimensions a free allowance is denominated in are hosted billing policy, and a
- * closed copy of them in the public package would be the duplication the prepaid
- * model was built to remove. These three are not policy. They are the whole
- * public answer to "what sized this workspace", they change only when the
- * product does, and a client switching on them wants the compiler to tell it
- * when a fourth appears.
- */
-/**
- * How the money gates size a workspace. There is no plan catalog: a saved card
- * and the auto-recharge flag are the only inputs, so the state is derived rather
- * than sold.
- *
- * - `free` — no card on file. Free monthly allowances only.
- * - `carded_manual` — a card is saved; credit is bought a top-up at a time.
- * - `carded_auto` — a card is saved and auto-recharge is on.
- */
-export declare const BILLING_ADMISSION_STATES: readonly ["free", "carded_manual", "carded_auto"];
-export type BillingAdmissionState = (typeof BILLING_ADMISSION_STATES)[number];

package/dist/_contracts/billing-admission.js

@@ -1,28 +0,0 @@
-/**
- * The admission vocabulary the money gates decide with.
- *
- * A LEAF module, importing nothing, for the same reason `schemas/runtime-kind.ts`
- * is one: four modules need this list — `runtime-types.ts` for `WhoAmI.limits`,
- * `account-types.ts` for `BillingSummary`, and the two response schemas that
- * check both against the wire — and any of them owning it would make the other
- * three import a much larger module for one constant, or force a cycle between a
- * schema and the types derived from it.
- *
- * Contrast an allowance `dimension`, which is deliberately an OPEN string: the
- * dimensions a free allowance is denominated in are hosted billing policy, and a
- * closed copy of them in the public package would be the duplication the prepaid
- * model was built to remove. These three are not policy. They are the whole
- * public answer to "what sized this workspace", they change only when the
- * product does, and a client switching on them wants the compiler to tell it
- * when a fourth appears.
- */
-/**
- * How the money gates size a workspace. There is no plan catalog: a saved card
- * and the auto-recharge flag are the only inputs, so the state is derived rather
- * than sold.
- *
- * - `free` — no card on file. Free monthly allowances only.
- * - `carded_manual` — a card is saved; credit is bought a top-up at a time.
- * - `carded_auto` — a card is saved and auto-recharge is on.
- */
-export const BILLING_ADMISSION_STATES = ["free", "carded_manual", "carded_auto"];

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

@@ -1,89 +0,0 @@
-/**
- * Bundle fidelity sidecar — the shared source of truth for the `.aexmeta.json`
- * metadata entry that rides inside a canonical bundle zip.
- *
- * A canonical bundle (skill / tool / file / instruction) is a deterministic zip of
- * regular files. fflate's `unzipSync` on the restore side is asymmetric: it
- * surfaces only entry bytes, never external attributes / os field / symlink
- * flags. So exec bits and symlinks — the metadata a local dir → zip →
- * container-restore round-trip must preserve — cannot travel in the zip's
- * external attributes and be read back. Instead they travel in ONE reserved
- * entry, `.aexmeta.json`, which both the SDK (encode) and the container
- * materializer (restore) agree on. This module is that agreement.
- *
- * SECURITY: {@link symlinkTargetEscapes} is a restore-time boundary — it decides
- * whether a captured symlink target may be recreated on the container FS. It is
- * PURELY LEXICAL (no realpath, no FS access → no TOCTOU) and is fuzzed. Both
- * repos import it; do not fork it.
- *
- * Determinism: the sidecar is emitted ONLY when there is metadata to carry (exec
- * or symlinks non-empty) and is serialized canonically (fixed field order, sorted
- * arrays, no insignificant whitespace, no trailing newline). A pure-content
- * bundle emits NO sidecar → its bytes stay identical to the pre-fidelity output,
- * so existing content-addressed dedup is preserved.
- */
-/** Reserved zip entry carrying the fidelity sidecar. Rejected as a user file path. */
-export declare const RESERVED_META_ENTRY = ".aexmeta.json";
-/** Normalised mode for an executable regular file (has any exec bit). */
-export declare const EXEC_MODE = 493;
-/** Normalised mode for an ordinary regular file. */
-export declare const DEFAULT_FILE_MODE = 420;
-/** Bundle-time cap on a captured symlink target string. */
-export declare const MAX_SYMLINK_TARGET_LENGTH = 4096;
-/** A captured symlink: `path` is the bundle-relative link name, `target` the raw `readlink()` string. */
-export interface BundleSymlink {
-    readonly path: string;
-    readonly target: string;
-}
-/**
- * The fidelity sidecar. `exec` lists the bundle-relative paths that restore to
- * {@link EXEC_MODE} (all other files stay {@link DEFAULT_FILE_MODE}); `symlinks`
- * lists links to recreate (subject to {@link symlinkTargetEscapes}).
- */
-export interface BundleManifest {
-    readonly v: 1;
-    readonly exec: readonly string[];
-    readonly symlinks: readonly BundleSymlink[];
-}
-/** True when a manifest carries no metadata worth emitting (so no sidecar is written). */
-export declare function bundleManifestIsEmpty(manifest: {
-    readonly exec?: readonly string[];
-    readonly symlinks?: readonly {
-        readonly path: string;
-    }[];
-}): boolean;
-/**
- * Serialize a manifest to canonical, byte-stable UTF-8 bytes: fixed field order
- * (`v`, `exec`, `symlinks`), `exec` sorted ascending, `symlinks` sorted by
- * `path`, no insignificant whitespace (compact JSON), no trailing newline. Two
- * equal manifests always serialize to identical bytes → the sidecar never
- * perturbs dedup determinism.
- */
-export declare function serializeBundleManifest(manifest: BundleManifest): Uint8Array;
-/**
- * Parse the sidecar bytes into a validated {@link BundleManifest}, or `null` when
- * the bytes are absent, not valid canonical JSON, or carry an unknown version.
- * Forward-compatible: an unknown `v` yields `null`. A known-v1 manifest is
- * atomic: every `exec` and `symlinks` entry must be structurally valid or the
- * whole sidecar returns `null`, so callers cannot silently materialize a partial
- * fidelity graph. The parse never throws.
- */
-export declare function tryParseBundleManifest(bytes: Uint8Array | null | undefined): BundleManifest | null;
-/** @deprecated Use {@link tryParseBundleManifest}; this compatibility wrapper is identical. */
-export declare function parseBundleManifest(bytes: Uint8Array | null | undefined): BundleManifest | null;
-/**
- * SECURITY boundary — decide whether recreating a symlink `linkRelPath` → `target`
- * would let the link escape the bundle root. PURELY LEXICAL (no realpath / no FS
- * access → no TOCTOU). Returns `true` (REJECT / do not create) when ANY of:
- *
- *   - `target` is empty or contains a NUL;
- *   - `target` is absolute — starts with `/`, matches a Windows drive (`C:`), is a
- *     UNC path (`\\host`), or contains any backslash;
- *   - the lexically-resolved target (join the link's dirname with the target, then
- *     normalise `.`/`..`) climbs at or above the bundle root (leading `..`).
- *
- * Otherwise the link is relative and resolves to a path inside (or at) the bundle
- * root — safe to recreate with the ORIGINAL relative `target`. A dangling in-root
- * target (pointing at a not-yet-existing sibling) is SAFE and allowed.
- */
-export declare function symlinkTargetEscapes(linkRelPath: string, target: string): boolean;

package/dist/_contracts/bundle-manifest.js

@@ -1,158 +0,0 @@
-/**
- * Bundle fidelity sidecar — the shared source of truth for the `.aexmeta.json`
- * metadata entry that rides inside a canonical bundle zip.
- *
- * A canonical bundle (skill / tool / file / instruction) is a deterministic zip of
- * regular files. fflate's `unzipSync` on the restore side is asymmetric: it
- * surfaces only entry bytes, never external attributes / os field / symlink
- * flags. So exec bits and symlinks — the metadata a local dir → zip →
- * container-restore round-trip must preserve — cannot travel in the zip's
- * external attributes and be read back. Instead they travel in ONE reserved
- * entry, `.aexmeta.json`, which both the SDK (encode) and the container
- * materializer (restore) agree on. This module is that agreement.
- *
- * SECURITY: {@link symlinkTargetEscapes} is a restore-time boundary — it decides
- * whether a captured symlink target may be recreated on the container FS. It is
- * PURELY LEXICAL (no realpath, no FS access → no TOCTOU) and is fuzzed. Both
- * repos import it; do not fork it.
- *
- * Determinism: the sidecar is emitted ONLY when there is metadata to carry (exec
- * or symlinks non-empty) and is serialized canonically (fixed field order, sorted
- * arrays, no insignificant whitespace, no trailing newline). A pure-content
- * bundle emits NO sidecar → its bytes stay identical to the pre-fidelity output,
- * so existing content-addressed dedup is preserved.
- */
-import { ASSET_ARCHIVE_LIMITS } from "./session-config.js";
-import { bundleManifestSidecarSchema, serializableBundleManifestSchema, tryParseBundleManifestSidecar } from "./schemas/bundle-manifest.js";
-import { parseWire } from "./schemas/wire.js";
-/** Reserved zip entry carrying the fidelity sidecar. Rejected as a user file path. */
-export const RESERVED_META_ENTRY = ".aexmeta.json";
-/** Normalised mode for an executable regular file (has any exec bit). */
-export const EXEC_MODE = 0o755;
-/** Normalised mode for an ordinary regular file. */
-export const DEFAULT_FILE_MODE = 0o644;
-/** Bundle-time cap on a captured symlink target string. */
-export const MAX_SYMLINK_TARGET_LENGTH = 4096;
-/**
- * Defensive cap on each metadata array, applied on both the encode and decode
- * sides. The decode side reaches it only after `JSON.parse` has already
- * materialised the array under {@link ASSET_ARCHIVE_LIMITS.maxMetadataBytes}, so
- * it bounds what the fidelity graph may contain rather than what the parser may
- * allocate.
- */
-const MAX_BUNDLE_METADATA_RECORDS = ASSET_ARCHIVE_LIMITS.maxEntries;
-/** True when a manifest carries no metadata worth emitting (so no sidecar is written). */
-export function bundleManifestIsEmpty(manifest) {
-    return (manifest.exec?.length ?? 0) === 0 && (manifest.symlinks?.length ?? 0) === 0;
-}
-const META_TEXT_ENCODER = new TextEncoder();
-const META_TEXT_DECODER = new TextDecoder("utf-8", { fatal: true });
-// Built once: the caps are module constants, so there is nothing per-call to
-// close over and no reason to pay schema construction on every sidecar.
-const SIDECAR_SCHEMA = bundleManifestSidecarSchema(MAX_BUNDLE_METADATA_RECORDS, MAX_SYMLINK_TARGET_LENGTH);
-const SERIALIZABLE_SCHEMA = serializableBundleManifestSchema(MAX_BUNDLE_METADATA_RECORDS, MAX_SYMLINK_TARGET_LENGTH);
-/**
- * Serialize a manifest to canonical, byte-stable UTF-8 bytes: fixed field order
- * (`v`, `exec`, `symlinks`), `exec` sorted ascending, `symlinks` sorted by
- * `path`, no insignificant whitespace (compact JSON), no trailing newline. Two
- * equal manifests always serialize to identical bytes → the sidecar never
- * perturbs dedup determinism.
- */
-export function serializeBundleManifest(manifest) {
-    parseWire(SERIALIZABLE_SCHEMA, manifest);
-    const exec = [...manifest.exec].sort(byString);
-    const symlinks = [...manifest.symlinks]
-        .map((s) => ({ path: s.path, target: s.target }))
-        .sort((a, b) => byString(a.path, b.path));
-    // Object literal key order is the wire order under JSON.stringify (fixed).
-    const json = JSON.stringify({ v: 1, exec, symlinks });
-    const bytes = META_TEXT_ENCODER.encode(json);
-    if (bytes.byteLength > ASSET_ARCHIVE_LIMITS.maxMetadataBytes) {
-        throw new Error("bundle fidelity metadata exceeds the 8 MiB limit");
-    }
-    return bytes;
-}
-/**
- * Parse the sidecar bytes into a validated {@link BundleManifest}, or `null` when
- * the bytes are absent, not valid canonical JSON, or carry an unknown version.
- * Forward-compatible: an unknown `v` yields `null`. A known-v1 manifest is
- * atomic: every `exec` and `symlinks` entry must be structurally valid or the
- * whole sidecar returns `null`, so callers cannot silently materialize a partial
- * fidelity graph. The parse never throws.
- */
-export function tryParseBundleManifest(bytes) {
-    if (!bytes || bytes.byteLength === 0)
-        return null;
-    if (bytes.byteLength > ASSET_ARCHIVE_LIMITS.maxMetadataBytes)
-        return null;
-    let parsed;
-    try {
-        parsed = JSON.parse(META_TEXT_DECODER.decode(bytes));
-    }
-    catch {
-        return null;
-    }
-    return tryParseBundleManifestSidecar(SIDECAR_SCHEMA, parsed);
-}
-/** @deprecated Use {@link tryParseBundleManifest}; this compatibility wrapper is identical. */
-export function parseBundleManifest(bytes) {
-    return tryParseBundleManifest(bytes);
-}
-/**
- * SECURITY boundary — decide whether recreating a symlink `linkRelPath` → `target`
- * would let the link escape the bundle root. PURELY LEXICAL (no realpath / no FS
- * access → no TOCTOU). Returns `true` (REJECT / do not create) when ANY of:
- *
- *   - `target` is empty or contains a NUL;
- *   - `target` is absolute — starts with `/`, matches a Windows drive (`C:`), is a
- *     UNC path (`\\host`), or contains any backslash;
- *   - the lexically-resolved target (join the link's dirname with the target, then
- *     normalise `.`/`..`) climbs at or above the bundle root (leading `..`).
- *
- * Otherwise the link is relative and resolves to a path inside (or at) the bundle
- * root — safe to recreate with the ORIGINAL relative `target`. A dangling in-root
- * target (pointing at a not-yet-existing sibling) is SAFE and allowed.
- */
-export function symlinkTargetEscapes(linkRelPath, target) {
-    if (typeof target !== "string" || target.length === 0)
-        return true;
-    if (target.includes("\0"))
-        return true;
-    // Absolute / platform-specific targets are always rejected.
-    if (target.startsWith("/"))
-        return true;
-    if (/^[A-Za-z]:/.test(target))
-        return true;
-    if (target.includes("\\"))
-        return true;
-    // Lexically resolve relative to the link's own directory.
-    const linkDir = posixDirname(linkRelPath);
-    const joined = linkDir.length > 0 ? `${linkDir}/${target}` : target;
-    const stack = [];
-    for (const segment of joined.split("/")) {
-        if (segment === "" || segment === ".")
-            continue;
-        if (segment === "..") {
-            // Pop an in-root component, or record an escaping climb.
-            if (stack.length > 0 && stack[stack.length - 1] !== "..") {
-                stack.pop();
-            }
-            else {
-                stack.push("..");
-            }
-        }
-        else {
-            stack.push(segment);
-        }
-    }
-    // A leading `..` means the resolved path is at or above the bundle root.
-    return stack.length > 0 && stack[0] === "..";
-}
-/** POSIX dirname of a forward-slash relative path ("" when there is no parent segment). */
-function posixDirname(path) {
-    const idx = path.lastIndexOf("/");
-    return idx <= 0 ? "" : path.slice(0, idx);
-}
-function byString(a, b) {
-    return a < b ? -1 : a > b ? 1 : 0;
-}

package/dist/_contracts/canonical-sha256.d.ts

@@ -1,8 +0,0 @@
-/**
- * Canonical algorithm-prefixed SHA-256 digest wire grammar.
- *
- * This accepts only the lowercase `sha256:` prefix followed by exactly 64
- * lowercase hexadecimal characters. Changing the algorithm, case, prefix, or
- * length is a wire-contract change.
- */
-export declare const CANONICAL_SHA256_DIGEST_PATTERN: RegExp;

package/dist/_contracts/canonical-sha256.js

@@ -1,8 +0,0 @@
-/**
- * Canonical algorithm-prefixed SHA-256 digest wire grammar.
- *
- * This accepts only the lowercase `sha256:` prefix followed by exactly 64
- * lowercase hexadecimal characters. Changing the algorithm, case, prefix, or
- * length is a wire-contract change.
- */
-export const CANONICAL_SHA256_DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/;

package/dist/_contracts/connection-ticket.d.ts

@@ -1,22 +0,0 @@
-/**
- * Connection tickets for the event-coordinator WebSocket handshake.
- *
- * A browser/runtime WebSocket handshake cannot carry an Authorization header,
- * so a subscriber first obtains a short-lived ticket from an authenticated
- * HTTP endpoint, then presents it as a `?ticket=` query parameter on the WS
- * upgrade. The ticket is an HMAC over `${sessionId}.${channel}.${exp}` keyed by
- * the coordinator secret — it binds the grant to one session, one stream channel,
- * and one expiry and is verified without any per-ticket storage.
- *
- * This lives in shared so the coordinator (which verifies) and the API
- * hosted API's ticket broker (which mints, on behalf of a workspace token) use
- * ONE implementation. Pure Web Crypto — identical under Bun and Node.
- */
-export type ConnectionTicketChannel = "event" | "log" | "all";
-/** Mint a `${channel}.${exp}.${mac}` ticket valid for `ttlMs` from `nowMs`. */
-export declare function mintConnectionTicket(sessionId: string, secret: string, nowMs: number, ttlMs?: number, channel?: ConnectionTicketChannel): Promise<{
-    ticket: string;
-    expiresAtMs: number;
-}>;
-/** Verify a ticket against `sessionId`, channel, and current time. Constant-time MAC compare. */
-export declare function verifyConnectionTicket(ticket: string, sessionId: string, secret: string, nowMs: number, channel?: ConnectionTicketChannel): Promise<boolean>;

package/dist/_contracts/connection-ticket.js

@@ -1,54 +0,0 @@
-/**
- * Connection tickets for the event-coordinator WebSocket handshake.
- *
- * A browser/runtime WebSocket handshake cannot carry an Authorization header,
- * so a subscriber first obtains a short-lived ticket from an authenticated
- * HTTP endpoint, then presents it as a `?ticket=` query parameter on the WS
- * upgrade. The ticket is an HMAC over `${sessionId}.${channel}.${exp}` keyed by
- * the coordinator secret — it binds the grant to one session, one stream channel,
- * and one expiry and is verified without any per-ticket storage.
- *
- * This lives in shared so the coordinator (which verifies) and the API
- * hosted API's ticket broker (which mints, on behalf of a workspace token) use
- * ONE implementation. Pure Web Crypto — identical under Bun and Node.
- */
-const DEFAULT_TICKET_TTL_MS = 60_000;
-const encoder = new TextEncoder();
-function normalizeTicketChannel(channel) {
-    return channel === "log" || channel === "all" ? channel : "event";
-}
-async function hmacHex(secret, message) {
-    const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-    const sig = await crypto.subtle.sign("HMAC", key, encoder.encode(message));
-    return [...new Uint8Array(sig)].map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-/** Mint a `${channel}.${exp}.${mac}` ticket valid for `ttlMs` from `nowMs`. */
-export async function mintConnectionTicket(sessionId, secret, nowMs, ttlMs = DEFAULT_TICKET_TTL_MS, channel = "event") {
-    const boundChannel = normalizeTicketChannel(channel);
-    const exp = nowMs + ttlMs;
-    const mac = await hmacHex(secret, `${sessionId}.${boundChannel}.${exp}`);
-    return { ticket: `${boundChannel}.${exp}.${mac}`, expiresAtMs: exp };
-}
-/** Verify a ticket against `sessionId`, channel, and current time. Constant-time MAC compare. */
-export async function verifyConnectionTicket(ticket, sessionId, secret, nowMs, channel = "event") {
-    const [ticketChannel, expRaw, mac, ...rest] = ticket.split(".");
-    if (rest.length > 0 || !ticketChannel || !expRaw || !mac)
-        return false;
-    const boundChannel = normalizeTicketChannel(channel);
-    if (ticketChannel !== boundChannel)
-        return false;
-    const exp = Number(expRaw);
-    if (!Number.isFinite(exp) || exp < nowMs)
-        return false;
-    const expected = await hmacHex(secret, `${sessionId}.${boundChannel}.${exp}`);
-    return timingSafeEqual(mac, expected);
-}
-/** Length-then-constant-time comparison of two hex strings. */
-function timingSafeEqual(a, b) {
-    if (a.length !== b.length)
-        return false;
-    let diff = 0;
-    for (let i = 0; i < a.length; i++)
-        diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
-    return diff === 0;
-}

package/dist/_contracts/continuation-event.d.ts

@@ -1,31 +0,0 @@
-/**
- * Dependency-free trace carrier used at continuation boundaries.
- *
- * This contract is internal to the aex runtime packages. It deliberately
- * lives in the public contracts package so every runtime consumes one wire
- * shape without importing a hosted-platform implementation package.
- */
-export interface W3CTraceContext {
-    readonly traceparent: string;
-    readonly tracestate?: string;
-}
-export declare const CONTINUATION_KINDS: readonly ["user_message", "tool_result", "scheduled_wake", "subagent_done"];
-export type ContinuationKind = (typeof CONTINUATION_KINDS)[number];
-export type ContinuationToken = string;
-/** Durable continuation payload shared by the outbox and queue transports. */
-export interface ContinuationEvent {
-    readonly kind: ContinuationKind;
-    readonly token: ContinuationToken;
-    readonly agentId: string;
-    readonly sessionId: string;
-    readonly observedEpoch?: number;
-    readonly turnSeq?: number;
-    readonly callId?: string;
-    readonly childAgentId?: string;
-    readonly wakeId?: string;
-    /** Semantic identity of the next planned action; excluded from token identity. */
-    readonly decisionFp?: string;
-    readonly requeueAttempt?: number;
-    /** W3C context propagated across the asynchronous continuation boundary. */
-    readonly traceContext?: W3CTraceContext;
-}

package/dist/_contracts/continuation-event.js

@@ -1,6 +0,0 @@
-export const CONTINUATION_KINDS = [
-    "user_message",
-    "tool_result",
-    "scheduled_wake",
-    "subagent_done"
-];

package/dist/_contracts/contract-parse-error.d.ts

@@ -1,12 +0,0 @@
-export declare const CONTRACT_PARSE_ERROR: "CONTRACT_PARSE_ERROR";
-declare const CONTRACT_PARSE_ERROR_BRAND: unique symbol;
-export type ContractParseError = Error & {
-    readonly code: typeof CONTRACT_PARSE_ERROR;
-    readonly parser: string;
-    readonly [CONTRACT_PARSE_ERROR_BRAND]: true;
-};
-export declare function isContractParseError(value: unknown): value is ContractParseError;
-export declare function markContractParseError(error: Error, parser: string): ContractParseError;
-export declare function rethrowContractParseError(error: unknown, parser: string): never;
-export declare function withContractParseError<T>(parser: string, parse: () => T): T;
-export {};

package/dist/_contracts/contract-parse-error.js

@@ -1,51 +0,0 @@
-export const CONTRACT_PARSE_ERROR = "CONTRACT_PARSE_ERROR";
-const CONTRACT_PARSE_ERROR_BRAND = Symbol("@aexhq/contracts/ContractParseError");
-export function isContractParseError(value) {
-    try {
-        return (value instanceof Error &&
-            value.code === CONTRACT_PARSE_ERROR &&
-            typeof value.parser === "string" &&
-            value[CONTRACT_PARSE_ERROR_BRAND] === true);
-    }
-    catch {
-        return false;
-    }
-}
-export function markContractParseError(error, parser) {
-    if (isContractParseError(error))
-        return error;
-    Object.defineProperties(error, {
-        code: {
-            value: CONTRACT_PARSE_ERROR,
-            enumerable: false,
-            writable: false,
-            configurable: false
-        },
-        parser: {
-            value: parser,
-            enumerable: false,
-            writable: false,
-            configurable: false
-        },
-        [CONTRACT_PARSE_ERROR_BRAND]: {
-            value: true,
-            enumerable: false,
-            writable: false,
-            configurable: false
-        }
-    });
-    return error;
-}
-export function rethrowContractParseError(error, parser) {
-    if (error instanceof Error)
-        throw markContractParseError(error, parser);
-    throw error;
-}
-export function withContractParseError(parser, parse) {
-    try {
-        return parse();
-    }
-    catch (error) {
-        rethrowContractParseError(error, parser);
-    }
-}

package/dist/_contracts/error-codes.d.ts

@@ -1,26 +0,0 @@
-/**
- * SSoT for the platform's STABLE API error codes.
- *
- * The server (platform `api.ts`) imports this table instead of keeping its
- * own private copy, so a route emitting a code absent from the union fails to
- * compile and adding a code without a message is caught. The SDK error factory
- * ({@link import("./error-factory.js").apiErrorFromResponse}) dispatches on the
- * code to a typed subclass; the CLI maps it to a human remedy.
- *
- * The code is the stable, machine-branchable identity of a failure — distinct
- * from the human `message`. `idempotency_conflict` and `insufficient_scope`
- * (previously message-less bare 409/403 bodies) are first-class here.
- */
-export declare const AEX_API_ERROR_CODES: readonly ["unauthorized", "forbidden", "insufficient_scope", "token_invalid", "token_revoked", "token_expired", "malformed_token", "not_found", "idempotency_conflict", "session_busy", "checkpoint_not_available", "session_not_terminal", "session_terminal", "event_archive_too_large", "event_archive_deadline_exceeded", "unknown_workspace", "workspace_inactive", "workspace_concurrency_exceeded", "workspace_submit_rate_exceeded", "workspace_spend_cap_exceeded", "workspace_cap_exceeded", "insufficient_credits", "account_blocked", "quota_exhausted", "depth_exceeded", "rate_limited", "out_of_memory", "disk_full", "content_deleted", "upstream_error", "internal_error"];
-export type AexApiErrorCode = (typeof AEX_API_ERROR_CODES)[number];
-/**
- * Human message per stable code. A `Record` (not `Partial`) so a code added to
- * {@link AEX_API_ERROR_CODES} without a message is a COMPILE error. These are
- * the fallback messages the factory uses when the server sends a BARE code with
- * no `message` detail.
- */
-export declare const AEX_API_ERROR_MESSAGES: Record<AexApiErrorCode, string>;
-/** Optional per-code fix hint the CLI surfaces alongside the error message. */
-export declare const AEX_API_ERROR_REMEDIES: Partial<Record<AexApiErrorCode, string>>;
-/** Narrow an arbitrary value to a known {@link AexApiErrorCode}. */
-export declare function isAexApiErrorCode(value: unknown): value is AexApiErrorCode;