@aexhq/sdk 0.46.4-canary → 0.50.0

package/dist/_contracts/api-routes.js

@@ -1,109 +0,0 @@
-/**
- * The authenticated data-plane HTTP route table.
- *
- * This is the single machine-readable description of the data-plane surface:
- * the platform api lambda dispatches and scope-gates from it, and the OpenAPI
- * generator in this repo reads the same table. It is declared here exactly
- * once so the two can never drift.
- *
- * Declaration-only and dependency-free: matching, scope lookup and route
- * classification stay with the server that dispatches them.
- */
-const route = (name, method, pattern, samplePath, requiredScope) => ({
-    name,
-    method,
-    pattern,
-    samplePath,
-    requiredScope,
-});
-export const AUTHENTICATED_API_ROUTE_DESCRIPTORS = [
-    // Valid-token canary.
-    route("whoami", "GET", /^\/whoami$/, "/whoami", null),
-    // Private runtime liveness of the exact writer baton. This is writer-token
-    // only at dispatch; it is not a bearer/public SDK surface.
-    route("runtime.writerAuthority", "GET", /^\/runtime\/writer-authority$/, "/runtime/writer-authority", null),
-    // (storage-model WS2) The credential-less container's DDB-decided journal commit channel: the api
-    // runs the fenced control-item write on its behalf. Writer-token only (same channel as
-    // writer-authority); the WS1 writerEpoch fence is applied at dispatch before this route runs.
-    route("runtime.journalCommit", "POST", /^\/runtime\/journal\/commit$/, "/runtime/journal/commit", null),
-    // Sessions.
-    route("sessions.create", "POST", /^\/sessions$/, "/sessions", "sessions:write"),
-    route("sessions.list", "GET", /^\/sessions$/, "/sessions", "sessions:read"),
-    route("sessions.listMessages", "GET", /^\/sessions\/[^/]+\/messages$/, "/sessions/sess_1/messages", "sessions:read"),
-    route("sessions.sendMessage", "POST", /^\/sessions\/[^/]+\/messages$/, "/sessions/sess_1/messages", "sessions:write"),
-    route("sessions.suspend", "POST", /^\/sessions\/[^/]+\/suspend$/, "/sessions/sess_1/suspend", "sessions:write"),
-    route("sessions.cancel", "POST", /^\/sessions\/[^/]+\/cancel$/, "/sessions/sess_1/cancel", "sessions:cancel"),
-    route("sessions.resume", "POST", /^\/sessions\/[^/]+\/resume$/, "/sessions/sess_1/resume", "sessions:write"),
-    route("sessions.requestApproval", "POST", /^\/sessions\/[^/]+\/request-approval$/, "/sessions/sess_1/request-approval", "sessions:write"),
-    route("sessions.approve", "POST", /^\/sessions\/[^/]+\/approve$/, "/sessions/sess_1/approve", "sessions:write"),
-    route("sessions.deny", "POST", /^\/sessions\/[^/]+\/deny$/, "/sessions/sess_1/deny", "sessions:write"),
-    route("sessions.delete", "DELETE", /^\/sessions\/[^/]+$/, "/sessions/sess_1", "sessions:delete"),
-    route("sessions.eventsTicket", "POST", /^\/sessions\/[^/]+\/events\/ticket$/, "/sessions/sess_1/events/ticket", "sessions:read"),
-    route("sessions.listEvents", "GET", /^\/sessions\/[^/]+\/events$/, "/sessions/sess_1/events", "sessions:read"),
-    route("sessions.otel", "GET", /^\/sessions\/[^/]+\/otel$/, "/sessions/sess_1/otel", "sessions:read"),
-    route("sessions.listChildren", "GET", /^\/sessions\/[^/]+\/children$/, "/sessions/sess_1/children", null),
-    route("sessions.childResult", "GET", /^\/sessions\/[^/]+\/result$/, "/sessions/sess_1/result", null),
-    route("sessions.eventArchiveLink", "POST", /^\/sessions\/[^/]+\/events\/link$/, "/sessions/sess_1/events/link", "sessions:read"),
-    route("sessions.downloadFile", "GET", /^\/sessions\/[^/]+\/files\/[^/]+\/download$/, "/sessions/sess_1/files/file_1/download", "files:read"),
-    route("sessions.fileLink", "POST", /^\/sessions\/[^/]+\/files\/[^/]+\/link$/, "/sessions/sess_1/files/file_1/link", "files:read"),
-    route("sessions.listFiles", "GET", /^\/sessions\/[^/]+\/files$/, "/sessions/sess_1/files", "files:read"),
-    route("sessions.listWebhookDeliveries", "GET", /^\/sessions\/[^/]+\/webhook-deliveries$/, "/sessions/sess_1/webhook-deliveries", "sessions:read"),
-    route("sessions.redeliverWebhook", "POST", /^\/sessions\/[^/]+\/webhook-deliveries\/[^/]+\/redeliver$/, "/sessions/sess_1/webhook-deliveries/del_1/redeliver", "sessions:write"),
-    route("sessions.archiveInternal", "GET", /^\/internal\/sessions\/[^/]+\/archive$/, "/internal/sessions/sess_1/archive", "files:read"),
-    route("sessions.get", "GET", /^\/sessions\/[^/]+$/, "/sessions/sess_1", "sessions:read"),
-    route("sessions.finalize", "POST", /^\/sessions\/[^/]+\/finalize$/, "/sessions/ses_1/finalize", "sessions:write"),
-    // Immutable content-addressed bytes backing every workspace resource family.
-    route("assets.presign", "POST", /^\/assets\/presign$/, "/assets/presign", "assets:write"),
-    route("assets.finalize", "POST", /^\/assets\/finalize$/, "/assets/finalize", "assets:write"),
-    route("assets.mpuPresignParts", "POST", /^\/assets\/mpu\/presign-parts$/, "/assets/mpu/presign-parts", "assets:write"),
-    route("assets.mpuAbort", "POST", /^\/assets\/mpu\/abort$/, "/assets/mpu/abort", "assets:write"),
-    route("assets.delete", "DELETE", /^\/assets\/[^/]+$/, "/assets/asset_1", "assets:delete"),
-    // Versioned workspace resources. The raw bytes stay in /assets; these routes
-    // publish and address immutable typed versions backed by those bytes.
-    route("workspace.files.publish", "POST", /^\/workspace\/files$/, "/workspace/files", "files:write"),
-    route("workspace.files.list", "GET", /^\/workspace\/files$/, "/workspace/files", "files:read"),
-    route("workspace.files.get", "GET", /^\/workspace\/files\/[^/]+$/, "/workspace/files/wres_1", "files:read"),
-    route("workspace.files.delete", "DELETE", /^\/workspace\/files\/[^/]+$/, "/workspace/files/wres_1", "files:delete"),
-    route("workspace.skills.publish", "POST", /^\/workspace\/skills$/, "/workspace/skills", "skills:write"),
-    route("workspace.skills.list", "GET", /^\/workspace\/skills$/, "/workspace/skills", "skills:read"),
-    route("workspace.skills.get", "GET", /^\/workspace\/skills\/[^/]+$/, "/workspace/skills/wres_1", "skills:read"),
-    route("workspace.skills.delete", "DELETE", /^\/workspace\/skills\/[^/]+$/, "/workspace/skills/wres_1", "skills:delete"),
-    route("workspace.tools.publish", "POST", /^\/workspace\/tools$/, "/workspace/tools", "tools:write"),
-    route("workspace.tools.list", "GET", /^\/workspace\/tools$/, "/workspace/tools", "tools:read"),
-    route("workspace.tools.get", "GET", /^\/workspace\/tools\/[^/]+$/, "/workspace/tools/wres_1", "tools:read"),
-    route("workspace.tools.delete", "DELETE", /^\/workspace\/tools\/[^/]+$/, "/workspace/tools/wres_1", "tools:delete"),
-    route("workspace.instructions.publish", "POST", /^\/workspace\/instructions$/, "/workspace/instructions", "instructions:write"),
-    route("workspace.instructions.list", "GET", /^\/workspace\/instructions$/, "/workspace/instructions", "instructions:read"),
-    route("workspace.instructions.get", "GET", /^\/workspace\/instructions\/[^/]+$/, "/workspace/instructions/wres_1", "instructions:read"),
-    route("workspace.instructions.delete", "DELETE", /^\/workspace\/instructions\/[^/]+$/, "/workspace/instructions/wres_1", "instructions:delete"),
-    // Workspace secret store.
-    route("secrets.create", "POST", /^\/secrets$/, "/secrets", "secrets:write"),
-    route("secrets.list", "GET", /^\/secrets$/, "/secrets", "secrets:read"),
-    route("secrets.rotate", "POST", /^\/secrets\/[^/]+\/rotate$/, "/secrets/NAME/rotate", "secrets:write"),
-    route("secrets.delete", "DELETE", /^\/secrets\/[^/]+$/, "/secrets/NAME", "secrets:write"),
-    route("secrets.get", "GET", /^\/secrets\/[^/]+$/, "/secrets/NAME", "secrets:read"),
-    // Workspace MCP server config.
-    route("mcpServers.create", "POST", /^\/mcp-servers$/, "/mcp-servers", "mcp:write"),
-    route("mcpServers.list", "GET", /^\/mcp-servers$/, "/mcp-servers", "mcp:read"),
-    route("mcpServers.delete", "DELETE", /^\/mcp-servers\/[^/]+$/, "/mcp-servers/mcp_abcdefghi", "mcp:delete"),
-    route("mcpServers.get", "GET", /^\/mcp-servers\/[^/]+$/, "/mcp-servers/mcp_abcdefghi", "mcp:read"),
-    // Billing (customer read + operator manage).
-    route("billing.get", "GET", /^\/billing$/, "/billing", "billing:read"),
-    route("billing.ledger", "GET", /^\/billing\/ledger$/, "/billing/ledger", "billing:read"),
-    route("billing.topupCheckout", "POST", /^\/billing\/topup\/checkout$/, "/billing/topup/checkout", "billing:read"),
-    route("billing.autoTopup", "PATCH", /^\/billing\/autotopup$/, "/billing/autotopup", "billing:read"),
-    // Monthly statements. The period segment is pinned to a UTC month rather than
-    // the usual `[^/]+`: a looser pattern would route `/billing/statements/../x`
-    // into the handler for it to reject, instead of refusing it at the door.
-    route("billing.statements", "GET", /^\/billing\/statements$/, "/billing/statements", "billing:read"),
-    route("billing.statement", "GET", /^\/billing\/statements\/[0-9]{4}-(0[1-9]|1[0-2])$/, "/billing/statements/2026-07", "billing:read"),
-    route("billing.portal", "POST", /^\/billing\/portal$/, "/billing/portal", "billing:read"),
-    route("adminBilling.topup", "POST", /^\/admin\/billing\/topup$/, "/admin/billing/topup", "billing:manage"),
-    route("adminBilling.paymentMethod", "POST", /^\/admin\/billing\/payment-method$/, "/admin/billing/payment-method", "billing:manage"),
-    route("adminBilling.accountType", "POST", /^\/admin\/billing\/account-type$/, "/admin/billing/account-type", "billing:manage"),
-    // Session webhooks (reveal/rotate signing secret + delivery ledger).
-    route("webhook.signingSecret", "POST", /^\/webhook\/signing-secret$/, "/webhook/signing-secret", "sessions:write"),
-    route("webhook.listDeliveries", "GET", /^\/webhook\/deliveries$/, "/webhook/deliveries", "sessions:read"),
-    // GDPR workspace hard-erase (owner self-service).
-    route("workspaces.erase", "DELETE", /^\/workspaces\/[^/]+$/, "/workspaces/ws_1", "workspaces:delete"),
-];

package/dist/_contracts/archive-limits.d.ts

@@ -1,3 +0,0 @@
-export declare function assertArchiveCompressedSize(size: number, source: string): void;
-export declare function assertArchiveExpandedSize(size: number, source: string): void;
-export declare function assertArchiveEntryCount(count: number, source: string): void;

package/dist/_contracts/archive-limits.js

@@ -1,23 +0,0 @@
-import { ASSET_ARCHIVE_LIMITS } from "./session-config.js";
-/** Render a byte ceiling the way the message quotes it, so the two cannot drift. */
-function mib(bytes) {
-    return `${bytes / (1024 * 1024)} MiB`;
-}
-export function assertArchiveCompressedSize(size, source) {
-    if (!Number.isSafeInteger(size) || size < 0 || size > ASSET_ARCHIVE_LIMITS.maxCompressedBytes) {
-        throw new Error(`${source} exceeds the ${mib(ASSET_ARCHIVE_LIMITS.maxCompressedBytes)} compressed limit ` +
-            `(got ${Number.isFinite(size) ? size : "an invalid byte count"})`);
-    }
-}
-export function assertArchiveExpandedSize(size, source) {
-    if (!Number.isSafeInteger(size) || size < 0 || size > ASSET_ARCHIVE_LIMITS.maxDecompressedBytes) {
-        throw new Error(`${source} exceeds the ${mib(ASSET_ARCHIVE_LIMITS.maxDecompressedBytes)} expanded limit ` +
-            `(got ${Number.isFinite(size) ? size : "an invalid byte count"})`);
-    }
-}
-export function assertArchiveEntryCount(count, source) {
-    if (!Number.isSafeInteger(count) || count < 0 || count > ASSET_ARCHIVE_LIMITS.maxEntries) {
-        throw new Error(`${source} exceeds the ${ASSET_ARCHIVE_LIMITS.maxEntries}-entry limit ` +
-            `(got ${Number.isFinite(count) ? count : "an invalid entry count"})`);
-    }
-}

package/dist/_contracts/asset-authoring.d.ts

@@ -1,22 +0,0 @@
-import { type ToolInputSchema } from "./session-config.js";
-import type { SkillFiles, ToolBundleManifest } from "./asset-bundle.js";
-export interface AssetToolManifestInput {
-    readonly name: string;
-    readonly description: string;
-    readonly inputSchema?: ToolInputSchema;
-    readonly input_schema?: ToolInputSchema;
-    readonly entry: string;
-}
-export interface SkillFrontmatter {
-    readonly name?: string;
-    readonly description?: string;
-}
-/** Internal authoring helper shared by the SDK and the bundled CLI. */
-export declare function extractSkillFrontmatter(source: string, files: SkillFiles): SkillFrontmatter;
-/** Minimal scalar-only YAML frontmatter reader used by public skill factories. */
-export declare function parseSkillFrontmatter(text: string): SkillFrontmatter;
-/** Resolve and validate the canonical skill name shared by SDK and CLI drafts. */
-export declare function deriveSkillName(source: string, frontmatterName: string | undefined, explicitName: string | undefined, dirBasename: string | undefined, diagnostics?: "sdk" | "cli"): string;
-/** Validate and canonicalize a tool manifest before it is archived. */
-export declare function normalizeToolManifest(source: string, input: AssetToolManifestInput, files?: SkillFiles, diagnostics?: "sdk" | "cli"): ToolBundleManifest;
-export declare function slugifyAssetName(input: string): string;

package/dist/_contracts/asset-authoring.js

@@ -1,106 +0,0 @@
-import { SKILL_NAME_PATTERN, SKILL_RESERVED_NAMES, TOOL_NAME_PATTERN, normaliseSkillBundlePath } from "./session-config.js";
-/** Internal authoring helper shared by the SDK and the bundled CLI. */
-export function extractSkillFrontmatter(source, files) {
-    const raw = files["SKILL.md"];
-    if (raw === undefined) {
-        throw new Error(`${source}: the skill bundle must contain a SKILL.md at its root`);
-    }
-    const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
-    return parseSkillFrontmatter(text);
-}
-/** Minimal scalar-only YAML frontmatter reader used by public skill factories. */
-export function parseSkillFrontmatter(text) {
-    const src = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
-    const match = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/.exec(src);
-    if (!match)
-        return {};
-    const out = {};
-    for (const line of match[1].split(/\r?\n/)) {
-        const kv = /^([A-Za-z0-9_-]+)[ \t]*:[ \t]*(.*)$/.exec(line);
-        if (!kv)
-            continue;
-        const key = kv[1].toLowerCase();
-        if (key !== "name" && key !== "description")
-            continue;
-        let value = kv[2].trim();
-        if (value.length >= 2 &&
-            ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'")))) {
-            value = value.slice(1, -1);
-        }
-        if (value.length > 0)
-            out[key] = value;
-    }
-    return out;
-}
-/** Resolve and validate the canonical skill name shared by SDK and CLI drafts. */
-export function deriveSkillName(source, frontmatterName, explicitName, dirBasename, diagnostics = "sdk") {
-    let name = explicitName ?? frontmatterName;
-    if (name === undefined && dirBasename !== undefined) {
-        const slug = slugifyAssetName(dirBasename);
-        if (slug.length > 0)
-            name = slug;
-    }
-    if (typeof name !== "string" || name.length === 0) {
-        if (diagnostics === "cli") {
-            throw new Error(`${source}: a skill name is required`);
-        }
-        throw new Error(`${source}: a skill name is required — pass { name }, add a \`name:\` field to the SKILL.md ` +
-            `YAML frontmatter, or (for fromDir) use a directory whose basename slugifies to a valid name`);
-    }
-    if (!SKILL_NAME_PATTERN.test(name)) {
-        throw new Error(`${source}: name ${JSON.stringify(name)} must match ${SKILL_NAME_PATTERN.source}`);
-    }
-    if (name.includes("__")) {
-        throw new Error(`${source}: name must not contain "__"; that separator is reserved for MCP tools`);
-    }
-    if (SKILL_RESERVED_NAMES.has(name)) {
-        if (diagnostics === "cli") {
-            throw new Error(`${source}: name ${JSON.stringify(name)} is reserved (${[...SKILL_RESERVED_NAMES].join(", ")})`);
-        }
-        throw new Error(`${source}: name ${JSON.stringify(name)} is reserved (${[...SKILL_RESERVED_NAMES].join(", ")}); pick another`);
-    }
-    return name;
-}
-/** Validate and canonicalize a tool manifest before it is archived. */
-export function normalizeToolManifest(source, input, files, diagnostics = "sdk") {
-    const name = input.name;
-    if (typeof name !== "string" || !TOOL_NAME_PATTERN.test(name)) {
-        throw new Error(`${source}: name must match ${TOOL_NAME_PATTERN.source}`);
-    }
-    if (name.includes("__")) {
-        throw new Error(`${source}: name must not contain "__"; that separator is reserved for MCP tools`);
-    }
-    const description = input.description;
-    if (typeof description !== "string" || description.trim().length === 0 || description.length > 2048) {
-        throw new Error(`${source}: description must be non-empty and <= 2048 chars`);
-    }
-    const inputSchema = input.inputSchema ?? input.input_schema;
-    if (!inputSchema || typeof inputSchema !== "object" || Array.isArray(inputSchema)) {
-        throw new Error(`${source}: inputSchema must be a JSON Schema object`);
-    }
-    if (inputSchema.type !== "object") {
-        throw new Error(`${source}: inputSchema.type must be "object"`);
-    }
-    const entry = normaliseSkillBundlePath(input.entry);
-    assertJsModuleEntry(source, entry, input.entry, files, diagnostics);
-    return { name, description, input_schema: inputSchema, entry };
-}
-export function slugifyAssetName(input) {
-    return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
-const JS_MODULE_ENTRY = /\.(?:js|mjs|cjs)$/i;
-function assertJsModuleEntry(source, entry, rawEntry, files, diagnostics) {
-    const basename = entry.split("/").pop() ?? entry;
-    if (!JS_MODULE_ENTRY.test(basename)) {
-        if (diagnostics === "cli") {
-            throw new Error(`${source}: entry must be a JS module (.js/.mjs/.cjs)`);
-        }
-        throw new Error(`${source}: entry must be a JS module (.js/.mjs/.cjs) that default-exports a function or { execute }; got ${JSON.stringify(rawEntry)}`);
-    }
-    if (files !== undefined && !(entry in files) && !(rawEntry in files)) {
-        if (diagnostics === "cli") {
-            throw new Error(`${source}: entry ${JSON.stringify(rawEntry)} is not present in files`);
-        }
-        throw new Error(`${source}: entry ${JSON.stringify(rawEntry)} is not present in files (keys: ${Object.keys(files).join(", ") || "(none)"})`);
-    }
-}

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

@@ -1,64 +0,0 @@
-import { type BundleSymlink } from "./bundle-manifest.js";
-import { type ToolInputSchema } from "./session-config.js";
-/**
- * In-memory skill bundle: a flat path -> bytes map and the
- * deterministically-zipped representation.
- *
- * Public authoring consumers run the cheap, safety-critical checks here
- * (`parseSkillBundleEntry`: no `..`, no absolute paths, no Windows
- * backslashes, depth/length limits). The BFF re-canonicalises and
- * recomputes the canonical hash on receipt. Client-side hashing is advisory
- * and exists to make uploads retry-safe and content-addressable.
- *
- * For workspace skills the SDK and CLI compute an advisory `sha256` of the
- * canonicalised zip via `hashSkillBundle()` before upserting the skill by name.
- * The platform verifies the hash against the uploaded bytes and uses it for
- * deduplication.
- */
-export interface BundledSkill {
-    readonly zip: Uint8Array;
-    readonly fileCount: number;
-    readonly compressedSize: number;
-}
-/** Inline files map: path -> contents (UTF-8 string or raw bytes). */
-export type SkillFiles = Readonly<Record<string, string | Uint8Array>>;
-/**
- * Fidelity metadata captured from a local directory walk: `exec` are the
- * bundle-relative paths that restore executable (0o755); `symlinks` are captured
- * links. When non-empty it is serialized into the {@link RESERVED_META_ENTRY}
- * sidecar, appended LAST so a pure-content bundle stays byte-identical to the
- * pre-fidelity output (dedup continuity).
- */
-export interface BundleMeta {
-    readonly exec?: readonly string[];
-    readonly symlinks?: readonly BundleSymlink[];
-}
-export interface ParsedSkillBundle {
-    readonly files: SkillFiles;
-    readonly meta?: BundleMeta;
-}
-/** Build the canonical single-entry archive used by File/Instructions drafts. */
-export declare function bundleSingleFile(path: string, bytes: Uint8Array, source: string, enforceCompressedLimit?: boolean): Uint8Array;
-/** Remove and parse the reserved fidelity sidecar before canonical rebundling. */
-export declare function splitSkillBundleMetadata(entries: Readonly<Record<string, Uint8Array>>, source: string): ParsedSkillBundle;
-export declare function bundleSkillFiles(files: SkillFiles, meta?: BundleMeta, diagnostics?: "sdk" | "cli"): BundledSkill;
-export interface BundledTool {
-    readonly zip: Uint8Array;
-    readonly fileCount: number;
-    readonly compressedSize: number;
-}
-export interface ToolBundleManifest {
-    readonly name: string;
-    readonly description: string;
-    readonly input_schema: ToolInputSchema;
-    readonly entry: string;
-}
-export declare function bundleToolFiles(files: SkillFiles, manifest: ToolBundleManifest, meta?: BundleMeta, diagnostics?: "sdk" | "cli"): BundledTool;
-/**
- * Compute `sha256:<hex>` of the given canonicalised zip bytes. Used by the
- * `Skill.from*` / `File` / `Instructions` factories to populate the draft's
- * `contentHash` field. The hash is advisory — the BFF verifies
- * it against the uploaded zip; a mismatch is rejected. Web-Crypto-only so the
- * SDK works in Bun, Node, edge runtimes, and browsers without polyfills.
- */
-export declare function hashSkillBundle(zipBytes: Uint8Array, diagnostics?: "sdk" | "cli"): Promise<string>;

package/dist/_contracts/asset-bundle.js

@@ -1,263 +0,0 @@
-import { zipSync } from "fflate";
-import { MAX_SYMLINK_TARGET_LENGTH, RESERVED_META_ENTRY, bundleManifestIsEmpty, tryParseBundleManifest, serializeBundleManifest } from "./bundle-manifest.js";
-import { SKILL_BUNDLE_LIMITS, parseSkillBundleEntry } from "./session-config.js";
-import { assertArchiveCompressedSize, assertArchiveEntryCount, assertArchiveExpandedSize } from "./archive-limits.js";
-import { archiveFileBytesSchema, bundleFidelityMetaSchema, bundleFileContentsSchema, bundleFilesMapSchema, bundleMetadataPathSchema, bundleSymlinkRecordSchema, bundleSymlinkTargetSchema } from "./schemas/asset-bundle.js";
-import { parseWire } from "./schemas/wire.js";
-const TEXT = new TextEncoder();
-/** Build the canonical single-entry archive used by File/Instructions drafts. */
-export function bundleSingleFile(path, bytes, source, enforceCompressedLimit = true) {
-    assertArchiveEntryCount(1, source);
-    assertArchiveExpandedSize(bytes.byteLength, source);
-    const zip = zipSync({ [path]: [bytes, { mtime: ZIP_EPOCH }] }, { level: 6 });
-    if (enforceCompressedLimit)
-        assertArchiveCompressedSize(zip.byteLength, source);
-    return zip;
-}
-/** Remove and parse the reserved fidelity sidecar before canonical rebundling. */
-export function splitSkillBundleMetadata(entries, source) {
-    const files = { ...entries };
-    const sidecar = files[RESERVED_META_ENTRY];
-    delete files[RESERVED_META_ENTRY];
-    const collected = collectCanonicalArchiveFiles(files, source);
-    if (sidecar === undefined) {
-        validateBundleGraph(collected, undefined, source);
-        return { files: Object.fromEntries(collected) };
-    }
-    const manifest = tryParseBundleManifest(sidecar);
-    if (manifest === null)
-        throw new Error(`${source}: invalid ${RESERVED_META_ENTRY} fidelity metadata`);
-    const meta = validateBundleGraph(collected, { exec: manifest.exec, symlinks: manifest.symlinks }, source);
-    return { files: Object.fromEntries(collected), ...(meta !== undefined ? { meta } : {}) };
-}
-/**
- * Build the ordered {@link Zippable} for a collected content map: content entries
- * sorted lexicographically, then (when `meta` carries any exec/symlink) the
- * canonical `.aexmeta.json` sidecar appended LAST. Insertion order is the zip
- * order (fflate iterates keys in insertion order), so the sidecar is always the
- * final entry and a metadata-free bundle is byte-identical to today's output.
- */
-function buildCanonicalZippable(collected, meta) {
-    const sorted = [...collected.entries()].sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
-    const zippable = {};
-    for (const [path, bytes] of sorted) {
-        zippable[path] = [bytes, { mtime: ZIP_EPOCH }];
-    }
-    let sidecarBytes = 0;
-    if (meta && !bundleManifestIsEmpty(meta)) {
-        const sidecar = serializeBundleManifest({ v: 1, exec: meta.exec ?? [], symlinks: meta.symlinks ?? [] });
-        sidecarBytes = sidecar.byteLength;
-        zippable[RESERVED_META_ENTRY] = [sidecar, { mtime: ZIP_EPOCH }];
-    }
-    return { zippable, sidecarBytes };
-}
-/** Reject a user file colliding with the reserved sidecar name (matches the `tool.json` precedent). */
-function assertNotReservedMetaPath(path, kind) {
-    if (path === RESERVED_META_ENTRY) {
-        throw new Error(`${kind} files must not include reserved "${RESERVED_META_ENTRY}"; fidelity metadata is emitted by the SDK`);
-    }
-}
-function collectCanonicalArchiveFiles(files, source) {
-    const entries = Object.entries(files);
-    assertArchiveEntryCount(entries.length, source);
-    const collected = new Map();
-    for (const [rawPath, bytes] of entries) {
-        parseWire(archiveFileBytesSchema(source, rawPath), bytes);
-        const path = parseSkillBundleEntry({ path: rawPath, size: bytes.byteLength }).path;
-        assertNotReservedMetaPath(path, source);
-        if (collected.has(path))
-            throw new Error(`${source} contains duplicate path: ${path}`);
-        collected.set(path, bytes);
-    }
-    return collected;
-}
-/** Validate the complete regular-file + fidelity-leaf graph before zipping. */
-function validateBundleGraph(collected, meta, source) {
-    assertArchiveEntryCount(collected.size, source);
-    const leaves = new Map();
-    for (const path of collected.keys())
-        leaves.set(path, "regular file");
-    if (meta === undefined) {
-        assertNoLeafPrefixConflicts(leaves, source);
-        return undefined;
-    }
-    const raw = parseWire(bundleFidelityMetaSchema(source), meta);
-    const rawExec = raw.exec ?? [];
-    const rawSymlinks = raw.symlinks ?? [];
-    assertArchiveEntryCount(rawExec.length, `${source} executable metadata`);
-    assertArchiveEntryCount(collected.size + rawSymlinks.length, source);
-    const exec = [];
-    const execSet = new Set();
-    for (const value of rawExec) {
-        const path = canonicalMetadataPath(value, source, "executable");
-        if (execSet.has(path))
-            throw new Error(`${source} contains duplicate executable path: ${path}`);
-        if (!collected.has(path)) {
-            throw new Error(`${source} executable path ${JSON.stringify(path)} must reference a regular file`);
-        }
-        execSet.add(path);
-        exec.push(path);
-    }
-    const symlinks = [];
-    for (const value of rawSymlinks) {
-        parseWire(bundleSymlinkRecordSchema(source), value);
-        const record = value;
-        const path = canonicalMetadataPath(record.path, source, "symlink");
-        const target = parseWire(bundleSymlinkTargetSchema(source, path, MAX_SYMLINK_TARGET_LENGTH), record.target);
-        const conflict = leaves.get(path);
-        if (conflict !== undefined) {
-            throw new Error(`${source} symlink path ${JSON.stringify(path)} conflicts with a ${conflict}`);
-        }
-        leaves.set(path, "symlink");
-        symlinks.push({ path, target });
-    }
-    assertNoLeafPrefixConflicts(leaves, source);
-    return { exec, symlinks };
-}
-function canonicalMetadataPath(value, source, kind) {
-    const supplied = parseWire(bundleMetadataPathSchema(source, kind), value);
-    let path;
-    try {
-        path = parseSkillBundleEntry({ path: supplied, size: 0 }).path;
-    }
-    catch (error) {
-        throw new Error(`${source} ${kind} path ${JSON.stringify(supplied)} is invalid: ` +
-            `${error instanceof Error ? error.message : String(error)}`);
-    }
-    if (path === RESERVED_META_ENTRY) {
-        throw new Error(`${source} ${kind} path must not use reserved ${JSON.stringify(RESERVED_META_ENTRY)}`);
-    }
-    return path;
-}
-function assertNoLeafPrefixConflicts(leaves, source) {
-    for (const path of leaves.keys()) {
-        let separator = path.lastIndexOf("/");
-        while (separator > 0) {
-            const ancestor = path.slice(0, separator);
-            if (leaves.has(ancestor)) {
-                throw new Error(`${source} leaf prefix conflict: ${JSON.stringify(ancestor)} conflicts with ${JSON.stringify(path)}`);
-            }
-            separator = ancestor.lastIndexOf("/");
-        }
-    }
-}
-/**
- * Canonical pipeline shared by skill and tool authoring. Kind policies own only
- * their required-root checks and any generated regular file; entry coercion,
- * validation, accounting, collection, archive finalization, and counting stay
- * byte-for-byte coupled here.
- */
-function bundleCanonicalFiles(files, meta, diagnostics, policy) {
-    const { kind } = policy;
-    const source = `${kind} bundle`;
-    parseWire(bundleFilesMapSchema(kind, source, SKILL_BUNDLE_LIMITS.maxFiles), files);
-    const entries = Object.entries(files);
-    const state = policy.prepare();
-    const collected = new Map();
-    let totalDecompressed = 0;
-    for (const [rawPath, contents] of entries) {
-        parseWire(bundleFileContentsSchema(kind, rawPath), contents);
-        const bytes = typeof contents === "string" ? TEXT.encode(contents) : contents;
-        const entry = parseSkillBundleEntry({ path: rawPath, size: bytes.byteLength });
-        assertNotReservedMetaPath(entry.path, source);
-        totalDecompressed += bytes.byteLength;
-        if (totalDecompressed > SKILL_BUNDLE_LIMITS.maxDecompressedBytes) {
-            throw new Error(`${source} exceeds decompressed cap of ${SKILL_BUNDLE_LIMITS.maxDecompressedBytes} bytes`);
-        }
-        if (collected.has(entry.path)) {
-            throw new Error(`${source} contains duplicate path: ${entry.path}`);
-        }
-        policy.visitEntry(state, entry.path);
-        collected.set(entry.path, bytes);
-    }
-    totalDecompressed += policy.complete(state, collected);
-    const validatedMeta = validateBundleGraph(collected, meta, source);
-    const { zippable, sidecarBytes } = buildCanonicalZippable(collected, validatedMeta);
-    assertArchiveExpandedSize(totalDecompressed + sidecarBytes, source);
-    const zip = zipSync(zippable, { level: 6 });
-    assertBundleCompressedSize(zip.byteLength, source, diagnostics);
-    return { zip, fileCount: collected.size, compressedSize: zip.byteLength };
-}
-export function bundleSkillFiles(files, meta, diagnostics = "sdk") {
-    return bundleCanonicalFiles(files, meta, diagnostics, {
-        kind: "Skill",
-        prepare: () => ({ hasSkillMd: false }),
-        visitEntry: (state, path) => {
-            if (path === "SKILL.md")
-                state.hasSkillMd = true;
-        },
-        complete: (state) => {
-            if (!state.hasSkillMd) {
-                throw new Error('Skill bundle must contain a "SKILL.md" file at the root. ' +
-                    "If you want to upload an instructions file or generic agent context, " +
-                    "use Instructions.fromPath / File.fromPath instead.");
-            }
-            return 0;
-        }
-    });
-}
-export function bundleToolFiles(files, manifest, meta, diagnostics = "sdk") {
-    return bundleCanonicalFiles(files, meta, diagnostics, {
-        kind: "Tool",
-        prepare: () => ({
-            entryPath: parseSkillBundleEntry({ path: manifest.entry, size: 0 }).path,
-            hasEntry: false
-        }),
-        visitEntry: (state, path) => {
-            if (path === state.entryPath)
-                state.hasEntry = true;
-        },
-        complete: (state, collected) => {
-            if (!state.hasEntry) {
-                throw new Error(`Tool bundle entry "${state.entryPath}" must exist in files`);
-            }
-            const manifestBytes = TEXT.encode(`${JSON.stringify(manifest, null, 2)}\n`);
-            if (collected.has("tool.json")) {
-                throw new Error('Tool bundle files must not include reserved "tool.json"; pass manifest fields to Tool.fromFiles instead');
-            }
-            collected.set("tool.json", manifestBytes);
-            return manifestBytes.byteLength;
-        }
-    });
-}
-const ZIP_EPOCH = new Date(Date.UTC(1980, 0, 1));
-/**
- * Compute `sha256:<hex>` of the given canonicalised zip bytes. Used by the
- * `Skill.from*` / `File` / `Instructions` factories to populate the draft's
- * `contentHash` field. The hash is advisory — the BFF verifies
- * it against the uploaded zip; a mismatch is rejected. Web-Crypto-only so the
- * SDK works in Bun, Node, edge runtimes, and browsers without polyfills.
- */
-export async function hashSkillBundle(zipBytes, diagnostics = "sdk") {
-    const subtle = globalThis.crypto?.subtle;
-    if (!subtle) {
-        if (diagnostics === "cli") {
-            throw new Error("sha256: globalThis.crypto.subtle is not available");
-        }
-        throw new Error("hashSkillBundle: globalThis.crypto.subtle is not available; Bun, Node 18+, or a Web-Crypto-capable runtime is required");
-    }
-    // crypto.subtle.digest expects a BufferSource. Pass a freshly-sliced
-    // copy to detach from any external Uint8Array view (Web Crypto rejects
-    // non-zero byteOffset SharedArrayBuffer views, and view detach also
-    // protects against the caller mutating the input after the digest is
-    // computed).
-    const view = new Uint8Array(zipBytes.byteLength);
-    view.set(zipBytes);
-    const digest = await subtle.digest("SHA-256", view.buffer);
-    return "sha256:" + bufferToHex(digest);
-}
-function assertBundleCompressedSize(size, source, diagnostics) {
-    if (diagnostics === "cli" && size > SKILL_BUNDLE_LIMITS.maxCompressedBytes) {
-        throw new Error(`bundle exceeds compressed cap of ${SKILL_BUNDLE_LIMITS.maxCompressedBytes} bytes (got ${size})`);
-    }
-    assertArchiveCompressedSize(size, source);
-}
-function bufferToHex(buffer) {
-    const view = new Uint8Array(buffer);
-    let out = "";
-    for (let i = 0; i < view.length; i++) {
-        const byte = view[i];
-        out += byte.toString(16).padStart(2, "0");
-    }
-    return out;
-}

package/dist/_contracts/asset-upload-helper.d.ts

@@ -1,31 +0,0 @@
-import { type HttpRetryDeps, type HttpRetryOptions } from "./http.js";
-export interface AssetUploadResponse {
-    readonly ok: boolean;
-    readonly status: number;
-    text(): Promise<string>;
-    readonly headers?: {
-        get(name: string): string | null;
-    };
-}
-/** Minimal fetch shape for direct-to-storage PUT requests. */
-export type AssetFetch = (input: string, init?: RequestInit) => Promise<AssetUploadResponse>;
-export type AssetUploadSleep = NonNullable<HttpRetryDeps["sleep"]>;
-/**
- * The shared {@link HttpRetryOptions} plus the injectable clock/RNG/sleep the
- * upload loops need. Direct-to-storage PUTs use the SAME policy numbers as the
- * API transport — there is no third set of defaults.
- */
-export interface AssetUploadRetryOptions extends HttpRetryOptions, HttpRetryDeps {
-}
-export declare function putDirectUploadWithRetry(fetchImpl: AssetFetch, uploadUrl: string, init: RequestInit, options?: AssetUploadRetryOptions): Promise<void>;
-/**
- * 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 declare function isRetryableUploadStatus(status: number): boolean;
-/** Every transport rejection except a caller-initiated abort is transient for a PUT. */
-export declare function isRetryableUploadError(err: unknown): boolean;
-export declare function directUploadNetworkError(uploadUrl: string, err: unknown, attempts: number): Error;
-export declare function directUploadResponseError(uploadUrl: string, status: number, detail: string, attempts: number): Error;
-export declare function sanitizeUploadText(text: string): string;