experimental-ash 0.25.2 → 0.27.0

package/dist/src/internal/attachments/sandbox-refs.js

@@ -1,78 +1 @@
-/**
- * Sandbox-resident attachment references.
- *
- * Refs are the compact wire format used after inbound attachment bytes
- * have been written into the sandbox:
- *
- * ```
- * ash-sandbox:?path=<urlencoded-resolved-path>&size=<bytes>&type=<mediaType>
- * ```
- */
-/**
- * Custom URL scheme used by every sandbox-resident attachment ref. The
- * trailing colon is part of the scheme per WHATWG URL semantics.
- */
-export const SANDBOX_URL_SCHEME = "ash-sandbox:";
-const PATH_QUERY_KEY = "path";
-const SIZE_QUERY_KEY = "size";
-const TYPE_QUERY_KEY = "type";
-function isValidSize(value) {
-    return Number.isFinite(value) && Number.isInteger(value) && value >= 0;
-}
-/**
- * Encodes a {@link SandboxRef} as a URL suitable for use as
- * `FilePart.data`.
- */
-export function encodeSandboxRef(ref) {
-    if (typeof ref.path !== "string" || ref.path.length === 0) {
-        throw new RangeError("SandboxRef.path must be a non-empty string.");
-    }
-    if (!isValidSize(ref.size)) {
-        throw new RangeError(`SandboxRef.size must be a non-negative integer. Received: ${String(ref.size)}.`);
-    }
-    if (typeof ref.mediaType !== "string" || ref.mediaType.length === 0) {
-        throw new RangeError("SandboxRef.mediaType must be a non-empty string.");
-    }
-    const url = new URL(SANDBOX_URL_SCHEME);
-    url.searchParams.set(PATH_QUERY_KEY, ref.path);
-    url.searchParams.set(SIZE_QUERY_KEY, String(ref.size));
-    url.searchParams.set(TYPE_QUERY_KEY, ref.mediaType);
-    return url;
-}
-/**
- * Parses a {@link SandboxRef} from its URL form.
- */
-export function decodeSandboxRef(value) {
-    const url = value instanceof URL ? value : new URL(value);
-    if (url.protocol !== SANDBOX_URL_SCHEME) {
-        throw new Error(`SandboxRef URL must use scheme "${SANDBOX_URL_SCHEME}". Got: "${url.protocol}".`);
-    }
-    const path = url.searchParams.get(PATH_QUERY_KEY);
-    if (path === null || path === "") {
-        throw new Error('SandboxRef URL is missing the required "path" query param.');
-    }
-    const sizeRaw = url.searchParams.get(SIZE_QUERY_KEY);
-    if (sizeRaw === null || sizeRaw === "") {
-        throw new Error('SandboxRef URL is missing the required "size" query param.');
-    }
-    const size = Number(sizeRaw);
-    if (!isValidSize(size)) {
-        throw new Error(`SandboxRef URL "size" must be a non-negative integer. Got: ${JSON.stringify(sizeRaw)}.`);
-    }
-    const mediaType = url.searchParams.get(TYPE_QUERY_KEY);
-    if (mediaType === null || mediaType === "") {
-        throw new Error('SandboxRef URL is missing the required "type" query param.');
-    }
-    return { mediaType, path, size };
-}
-/**
- * Cheap runtime check: does this value look like a sandbox-ref URL?
- *
- * Accepts `URL` instances with the `ash-sandbox:` scheme. Strings are
- * NOT accepted — the staging and hydration layers only inspect
- * URL-instance `FilePart.data` values, matching the existing
- * `data instanceof URL` branch in `fileDataToBytes`.
- */
-export function isSandboxRefUrl(value) {
-    return value instanceof URL && value.protocol === SANDBOX_URL_SCHEME;
-}
+var SANDBOX_URL_SCHEME=`ash-sandbox:`,PATH_QUERY_KEY=`path`,SIZE_QUERY_KEY=`size`,TYPE_QUERY_KEY=`type`;function isValidSize(e){return Number.isFinite(e)&&Number.isInteger(e)&&e>=0}function encodeSandboxRef(t){if(typeof t.path!=`string`||t.path.length===0)throw RangeError(`SandboxRef.path must be a non-empty string.`);if(!isValidSize(t.size))throw RangeError(`SandboxRef.size must be a non-negative integer. Received: ${String(t.size)}.`);if(typeof t.mediaType!=`string`||t.mediaType.length===0)throw RangeError(`SandboxRef.mediaType must be a non-empty string.`);let n=new URL(SANDBOX_URL_SCHEME);return n.searchParams.set(PATH_QUERY_KEY,t.path),n.searchParams.set(SIZE_QUERY_KEY,String(t.size)),n.searchParams.set(TYPE_QUERY_KEY,t.mediaType),n}function decodeSandboxRef(t){let n=t instanceof URL?t:new URL(t);if(n.protocol!==`ash-sandbox:`)throw Error(`SandboxRef URL must use scheme "${SANDBOX_URL_SCHEME}". Got: "${n.protocol}".`);let r=n.searchParams.get(PATH_QUERY_KEY);if(r===null||r===``)throw Error(`SandboxRef URL is missing the required "path" query param.`);let i=n.searchParams.get(SIZE_QUERY_KEY);if(i===null||i===``)throw Error(`SandboxRef URL is missing the required "size" query param.`);let a=Number(i);if(!isValidSize(a))throw Error(`SandboxRef URL "size" must be a non-negative integer. Got: ${JSON.stringify(i)}.`);let o=n.searchParams.get(TYPE_QUERY_KEY);if(o===null||o===``)throw Error(`SandboxRef URL is missing the required "type" query param.`);return{mediaType:o,path:r,size:a}}function isSandboxRefUrl(e){return e instanceof URL&&e.protocol===`ash-sandbox:`}export{SANDBOX_URL_SCHEME,decodeSandboxRef,encodeSandboxRef,isSandboxRefUrl};

package/dist/src/internal/attachments/url-refs.js

@@ -1,20 +1 @@
-/**
- * Custom URL scheme for serializing `URL` objects in `FilePart.data`
- * across the queue boundary.
- *
- * Route handlers place `new URL("https://...")` on `FilePart.data`.
- * Before the message crosses the queue, `send()` rewrites these as
- * `ash-url:https://...` strings. After the queue, the staging pipeline
- * reconstitutes them back to `URL` objects so `instanceof URL` checks
- * work reliably.
- */
-const ASH_URL_SCHEME = "ash-url:";
-export function serializeUrlFilePart(url) {
-    return `${ASH_URL_SCHEME}${url.href}`;
-}
-export function isSerializedUrlFilePart(data) {
-    return typeof data === "string" && data.startsWith(ASH_URL_SCHEME);
-}
-export function deserializeUrlFilePart(data) {
-    return new URL(data.slice(ASH_URL_SCHEME.length));
-}
+var ASH_URL_SCHEME=`ash-url:`;function serializeUrlFilePart(e){return`${ASH_URL_SCHEME}${e.href}`}function isSerializedUrlFilePart(e){return typeof e==`string`&&e.startsWith(ASH_URL_SCHEME)}function deserializeUrlFilePart(e){return new URL(e.slice(ASH_URL_SCHEME.length))}export{deserializeUrlFilePart,isSerializedUrlFilePart,serializeUrlFilePart};

package/dist/src/internal/authored-asset-import-plugin.js

@@ -1,141 +1 @@
-import { readFile } from "node:fs/promises";
-import { dirname, extname, isAbsolute, resolve } from "node:path";
-const AUTHORED_ASSET_CODE_EXTENSIONS = [
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".json",
-];
-/**
- * Creates the Rollup-compatible plugin that gives authored modules a small
- * asset-module surface for non-code relative imports.
- */
-export function createAuthoredAssetImportPlugin() {
-    return {
-        name: "ash-authored-asset-import",
-        resolveId(source, importer) {
-            if (!isPotentialAuthoredAssetImport(source) || importer === undefined) {
-                return undefined;
-            }
-            const { path, suffix } = splitImportSuffix(source);
-            const resolvedPath = isAbsolute(path) ? path : resolve(dirname(importer), path);
-            return `${resolvedPath}${suffix}`;
-        },
-        async load(id) {
-            const { path, suffix } = splitImportSuffix(id);
-            if (!isPotentialAuthoredAssetImport(path)) {
-                return undefined;
-            }
-            if (suffix === "?raw") {
-                const source = await readAssetText(path);
-                if (source === undefined) {
-                    return undefined;
-                }
-                return {
-                    code: `export default ${JSON.stringify(source)};`,
-                    moduleType: "js",
-                };
-            }
-            const dataUrl = await readAssetDataUrl(path);
-            if (dataUrl === undefined) {
-                return undefined;
-            }
-            return {
-                code: `export default ${JSON.stringify(dataUrl)};`,
-                moduleType: "js",
-            };
-        },
-    };
-}
-async function readAssetText(path) {
-    try {
-        return await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (isPathNotFoundError(error)) {
-            return undefined;
-        }
-        throw error;
-    }
-}
-function isPotentialAuthoredAssetImport(source) {
-    if (source.startsWith("\0") ||
-        source.startsWith("node:") ||
-        source.startsWith("data:") ||
-        source.startsWith("file:")) {
-        return false;
-    }
-    const { path } = splitImportSuffix(source);
-    if (!path.startsWith(".") && !path.startsWith("/") && !/^[A-Za-z]:[\\/]/.test(path)) {
-        return false;
-    }
-    const extension = extname(path);
-    return (extension.length > 0 &&
-        extension !== ".node" &&
-        !AUTHORED_ASSET_CODE_EXTENSIONS.includes(extension));
-}
-function splitImportSuffix(specifier) {
-    const queryIndex = specifier.indexOf("?");
-    const hashIndex = specifier.indexOf("#");
-    const suffixIndex = queryIndex === -1 ? hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
-    if (suffixIndex === -1) {
-        return {
-            path: specifier,
-            suffix: "",
-        };
-    }
-    return {
-        path: specifier.slice(0, suffixIndex),
-        suffix: specifier.slice(suffixIndex),
-    };
-}
-async function readAssetDataUrl(path) {
-    try {
-        const bytes = await readFile(path);
-        return `data:${getAssetMimeType(path)};base64,${bytes.toString("base64")}`;
-    }
-    catch (error) {
-        if (isPathNotFoundError(error)) {
-            return undefined;
-        }
-        throw error;
-    }
-}
-function isPathNotFoundError(error) {
-    return (typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        (error.code === "ENOENT" || error.code === "ENOTDIR"));
-}
-function getAssetMimeType(path) {
-    switch (extname(path).toLowerCase()) {
-        case ".css":
-            return "text/css";
-        case ".csv":
-            return "text/csv";
-        case ".gif":
-            return "image/gif";
-        case ".html":
-            return "text/html";
-        case ".jpg":
-        case ".jpeg":
-            return "image/jpeg";
-        case ".png":
-            return "image/png";
-        case ".svg":
-            return "image/svg+xml";
-        case ".txt":
-            return "text/plain";
-        case ".wasm":
-            return "application/wasm";
-        case ".webp":
-            return "image/webp";
-        default:
-            return "application/octet-stream";
-    }
-}
+import{dirname,extname,isAbsolute,resolve}from"node:path";import{readFile}from"node:fs/promises";var AUTHORED_ASSET_CODE_EXTENSIONS=[`.ts`,`.tsx`,`.mts`,`.cts`,`.js`,`.jsx`,`.mjs`,`.cjs`,`.json`];function createAuthoredAssetImportPlugin(){return{name:`ash-authored-asset-import`,resolveId(t,i){if(!isPotentialAuthoredAssetImport(t)||i===void 0)return;let{path:a,suffix:o}=splitImportSuffix(t);return`${isAbsolute(a)?a:resolve(dirname(i),a)}${o}`},async load(e){let{path:t,suffix:n}=splitImportSuffix(e);if(!isPotentialAuthoredAssetImport(t))return;if(n===`?raw`){let e=await readAssetText(t);return e===void 0?void 0:{code:`export default ${JSON.stringify(e)};`,moduleType:`js`}}let r=await readAssetDataUrl(t);if(r!==void 0)return{code:`export default ${JSON.stringify(r)};`,moduleType:`js`}}}}async function readAssetText(e){try{return await readFile(e,`utf8`)}catch(e){if(isPathNotFoundError(e))return;throw e}}function isPotentialAuthoredAssetImport(e){if(e.startsWith(`\0`)||e.startsWith(`node:`)||e.startsWith(`data:`)||e.startsWith(`file:`))return!1;let{path:n}=splitImportSuffix(e);if(!n.startsWith(`.`)&&!n.startsWith(`/`)&&!/^[A-Za-z]:[\\/]/.test(n))return!1;let r=extname(n);return r.length>0&&r!==`.node`&&!AUTHORED_ASSET_CODE_EXTENSIONS.includes(r)}function splitImportSuffix(e){let t=e.indexOf(`?`),n=e.indexOf(`#`),r=t===-1?n:n===-1?t:Math.min(t,n);return r===-1?{path:e,suffix:``}:{path:e.slice(0,r),suffix:e.slice(r)}}async function readAssetDataUrl(e){try{let t=await readFile(e);return`data:${getAssetMimeType(e)};base64,${t.toString(`base64`)}`}catch(e){if(isPathNotFoundError(e))return;throw e}}function isPathNotFoundError(e){return typeof e==`object`&&!!e&&`code`in e&&(e.code===`ENOENT`||e.code===`ENOTDIR`)}function getAssetMimeType(e){switch(extname(e).toLowerCase()){case`.css`:return`text/css`;case`.csv`:return`text/csv`;case`.gif`:return`image/gif`;case`.html`:return`text/html`;case`.jpg`:case`.jpeg`:return`image/jpeg`;case`.png`:return`image/png`;case`.svg`:return`image/svg+xml`;case`.txt`:return`text/plain`;case`.wasm`:return`application/wasm`;case`.webp`:return`image/webp`;default:return`application/octet-stream`}}export{createAuthoredAssetImportPlugin};

package/dist/src/internal/authored-definition/channel.js

@@ -1,21 +1 @@
-import { isCompiledChannel } from "#channel/compiled-channel.js";
-/**
- * Normalizes one authored channel definition into the canonical internal
- * shape consumed by the compiler.
- *
- * Authored channels must go through {@link defineChannel} (or a wrapper
- * like `slackChannel` / `ashChannel`) and therefore must be
- * {@link CompiledChannel} values. The legacy plain-`{ fetch, receive? }`
- * Route shape is no longer supported — drop a clear error for it so
- * users on old patterns get a useful migration hint instead of a silent
- * runtime crash deeper in dispatch.
- *
- * Disable sentinels are handled by the compiler before this function is
- * called.
- */
-export function normalizeChannelDefinition(value, message) {
-    if (!isCompiledChannel(value)) {
-        throw new Error(`${message} Use \`defineChannel({ routes, ... })\` (or a wrapper like \`slackChannel\` / \`ashChannel\`) — bare \`{ fetch, receive? }\` channel objects are no longer supported.`);
-    }
-    return value;
-}
+import{isCompiledChannel}from"#channel/compiled-channel.js";function normalizeChannelDefinition(e,t){if(!isCompiledChannel(e))throw Error(`${t} Use \`defineChannel({ routes, ... })\` (or a wrapper like \`slackChannel\` / \`ashChannel\`) — bare \`{ fetch, receive? }\` channel objects are no longer supported.`);return e}export{normalizeChannelDefinition};

package/dist/src/internal/authored-definition/connection.js

@@ -1,148 +1 @@
-import { normalizeAuthorizationSpec } from "#runtime/connections/validate-authorization.js";
-import { expectObjectRecord, expectOnlyKnownKeys } from "#internal/authored-module.js";
-const KNOWN_TOP_LEVEL_KEYS = [
-    "approval",
-    "auth",
-    "description",
-    "headers",
-    "tools",
-    "url",
-];
-const KNOWN_AUTHORIZATION_KEYS = [
-    "completeAuthorization",
-    "getToken",
-    "principalType",
-    "startAuthorization",
-    // Optional metadata marker that auth-provider helpers may attach so
-    // downstream tooling (eg. the Ash compiler / Vercel dashboard) can
-    // detect Vercel Connect-backed connections without opening the
-    // closure state of `getToken`. The runtime never reads it; it
-    // survives `normalizeAuthorizationSpec` so consumers can pick it
-    // off the normalized auth definition. See
-    // `runtime/connections/types.ts#AuthorizationDefinitionBase` for
-    // the type and `@vercel/connect/ash`'s `connect()` for the
-    // canonical producer.
-    "vercelConnect",
-];
-/**
- * Validates one authored MCP client connection module export at build time
- * and returns the public definition type. The module export is `unknown`
- * because it comes from a dynamically-loaded authored file; this function
- * bridges the gap with runtime checks so authoring errors surface during
- * `ash build`.
- */
-export function normalizeMcpClientConnectionDefinition(value, message) {
-    const record = expectObjectRecord(value, message);
-    expectOnlyKnownKeys(record, KNOWN_TOP_LEVEL_KEYS, message);
-    validateUrl(record, message);
-    validateDescription(record, message);
-    const authorization = normalizeAuthorization(record, message);
-    const headers = normalizeHeaders(record, message);
-    const tools = normalizeToolFilter(record, message);
-    if (authorization !== undefined && headers !== undefined && typeof headers !== "function") {
-        const headerKeys = Object.keys(headers);
-        if (headerKeys.some((k) => k.toLowerCase() === "authorization")) {
-            throw new Error(`${message} "headers" must not include an "Authorization" key when "auth" is also provided.`);
-        }
-    }
-    const result = {
-        description: record.description,
-        url: record.url,
-    };
-    if (authorization !== undefined) {
-        result.auth = authorization;
-    }
-    if (headers !== undefined) {
-        result.headers = headers;
-    }
-    if (tools !== undefined) {
-        result.tools = tools;
-    }
-    if (record.approval !== undefined) {
-        if (typeof record.approval !== "function") {
-            throw new Error(`${message} The "approval" field must be a function when provided.`);
-        }
-        result.approval = record.approval;
-    }
-    return result;
-}
-function validateUrl(record, message) {
-    if (typeof record.url !== "string" || !URL.canParse(record.url)) {
-        throw new Error(`${message} The "url" field must be a valid URL.`);
-    }
-    const parsed = new URL(record.url);
-    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
-        throw new Error(`${message} The "url" field must use the http or https protocol, got "${parsed.protocol}".`);
-    }
-}
-function validateDescription(record, message) {
-    if (typeof record.description !== "string" || record.description.length === 0) {
-        throw new Error(`${message} The "description" field must be a non-empty string.`);
-    }
-}
-function normalizeAuthorization(record, message) {
-    if (record.auth === undefined) {
-        return undefined;
-    }
-    const auth = expectObjectRecord(record.auth, `${message} The "auth" field must be an object with a "getToken" method.`);
-    expectOnlyKnownKeys(auth, KNOWN_AUTHORIZATION_KEYS, `${message} The "auth" field`);
-    return normalizeAuthorizationSpec(auth, message);
-}
-function normalizeHeaders(record, message) {
-    if (record.headers === undefined) {
-        return undefined;
-    }
-    if (typeof record.headers === "function") {
-        return record.headers;
-    }
-    if (typeof record.headers !== "object" ||
-        record.headers === null ||
-        Array.isArray(record.headers)) {
-        throw new Error(`${message} The "headers" field must be a plain object or a function.`);
-    }
-    const headersRecord = record.headers;
-    for (const [key, val] of Object.entries(headersRecord)) {
-        const valType = typeof val;
-        if (valType !== "string" && valType !== "function" && valType !== "object") {
-            throw new Error(`${message} The "headers.${key}" value must be a string, Promise, or function.`);
-        }
-        if (valType === "object" &&
-            (val === null || typeof val.then !== "function")) {
-            throw new Error(`${message} The "headers.${key}" value must be a string, Promise, or function.`);
-        }
-    }
-    return headersRecord;
-}
-function normalizeToolFilter(record, message) {
-    if (record.tools === undefined) {
-        return undefined;
-    }
-    if (typeof record.tools !== "object" || record.tools === null || Array.isArray(record.tools)) {
-        throw new Error(`${message} The "tools" field must specify either "allow" or "block".`);
-    }
-    const toolsRecord = record.tools;
-    const hasAllow = "allow" in toolsRecord;
-    const hasBlock = "block" in toolsRecord;
-    if (hasAllow && hasBlock) {
-        throw new Error(`${message} The "tools" field must specify either "allow" or "block", not both.`);
-    }
-    if (!hasAllow && !hasBlock) {
-        throw new Error(`${message} The "tools" field must specify either "allow" or "block".`);
-    }
-    if (hasAllow) {
-        validateStringArray(toolsRecord.allow, `${message} The "tools.allow"`);
-        return { allow: toolsRecord.allow };
-    }
-    validateStringArray(toolsRecord.block, `${message} The "tools.block"`);
-    return { block: toolsRecord.block };
-}
-function validateStringArray(value, label) {
-    if (!Array.isArray(value)) {
-        throw new Error(`${label} field must be an array of strings.`);
-    }
-    for (let i = 0; i < value.length; i++) {
-        if (typeof value[i] !== "string") {
-            throw new Error(`${label}[${i}] must be a string.`);
-        }
-    }
-}
+import{expectObjectRecord,expectOnlyKnownKeys}from"#internal/authored-module.js";import{normalizeAuthorizationSpec}from"#runtime/connections/validate-authorization.js";var KNOWN_TOP_LEVEL_KEYS=[`approval`,`auth`,`description`,`headers`,`tools`,`url`],KNOWN_AUTHORIZATION_KEYS=[`completeAuthorization`,`getToken`,`principalType`,`startAuthorization`,`vercelConnect`];function normalizeMcpClientConnectionDefinition(n,i){let a=expectObjectRecord(n,i);expectOnlyKnownKeys(a,KNOWN_TOP_LEVEL_KEYS,i),validateUrl(a,i),validateDescription(a,i);let o=normalizeAuthorization(a,i),s=normalizeHeaders(a,i),c=normalizeToolFilter(a,i);if(o!==void 0&&s!==void 0&&typeof s!=`function`&&Object.keys(s).some(e=>e.toLowerCase()===`authorization`))throw Error(`${i} "headers" must not include an "Authorization" key when "auth" is also provided.`);let l={description:a.description,url:a.url};if(o!==void 0&&(l.auth=o),s!==void 0&&(l.headers=s),c!==void 0&&(l.tools=c),a.approval!==void 0){if(typeof a.approval!=`function`)throw Error(`${i} The "approval" field must be a function when provided.`);l.approval=a.approval}return l}function validateUrl(e,t){if(typeof e.url!=`string`||!URL.canParse(e.url))throw Error(`${t} The "url" field must be a valid URL.`);let n=new URL(e.url);if(n.protocol!==`https:`&&n.protocol!==`http:`)throw Error(`${t} The "url" field must use the http or https protocol, got "${n.protocol}".`)}function validateDescription(e,t){if(typeof e.description!=`string`||e.description.length===0)throw Error(`${t} The "description" field must be a non-empty string.`)}function normalizeAuthorization(r,a){if(r.auth===void 0)return;let o=expectObjectRecord(r.auth,`${a} The "auth" field must be an object with a "getToken" method.`);return expectOnlyKnownKeys(o,KNOWN_AUTHORIZATION_KEYS,`${a} The "auth" field`),normalizeAuthorizationSpec(o,a)}function normalizeHeaders(e,t){if(e.headers===void 0)return;if(typeof e.headers==`function`)return e.headers;if(typeof e.headers!=`object`||e.headers===null||Array.isArray(e.headers))throw Error(`${t} The "headers" field must be a plain object or a function.`);let n=e.headers;for(let[e,r]of Object.entries(n)){let n=typeof r;if(n!==`string`&&n!==`function`&&n!==`object`||n===`object`&&(r===null||typeof r.then!=`function`))throw Error(`${t} The "headers.${e}" value must be a string, Promise, or function.`)}return n}function normalizeToolFilter(e,t){if(e.tools===void 0)return;if(typeof e.tools!=`object`||e.tools===null||Array.isArray(e.tools))throw Error(`${t} The "tools" field must specify either "allow" or "block".`);let n=e.tools,r=`allow`in n,i=`block`in n;if(r&&i)throw Error(`${t} The "tools" field must specify either "allow" or "block", not both.`);if(!r&&!i)throw Error(`${t} The "tools" field must specify either "allow" or "block".`);return r?(validateStringArray(n.allow,`${t} The "tools.allow"`),{allow:n.allow}):(validateStringArray(n.block,`${t} The "tools.block"`),{block:n.block})}function validateStringArray(e,t){if(!Array.isArray(e))throw Error(`${t} field must be an array of strings.`);for(let n=0;n<e.length;n++)if(typeof e[n]!=`string`)throw Error(`${t}[${n}] must be a string.`)}export{normalizeMcpClientConnectionDefinition};

package/dist/src/internal/authored-definition/core.js

@@ -1,180 +1 @@
-import { expectFunction, expectObjectRecord, expectOnlyKnownKeys, expectProviderOptions, expectString, getOptionalStringRecordProperty, } from "#internal/authored-module.js";
-/**
- * Normalizes one authored agent definition into the canonical internal shape.
- *
- * Authored `name` fields are rejected — agent identity is derived at compile
- * time from `manifest.agentId` (package name or app-root basename).
- */
-export function normalizeAgentDefinition(value, message) {
-    const record = expectObjectRecord(value, message);
-    expectOnlyKnownKeys(record, [
-        "build",
-        "compaction",
-        "description",
-        "metadata",
-        "model",
-        "modelContextWindowTokens",
-        "modelOptions",
-    ], message);
-    if (record.model === undefined) {
-        throw new Error(`${message} The "model" field is required.`);
-    }
-    const definition = {
-        model: record.model,
-    };
-    if (record.description !== undefined) {
-        definition.description = expectString(record.description, message);
-    }
-    const metadata = getOptionalStringRecordProperty(record, "metadata", message);
-    if (metadata !== undefined) {
-        definition.metadata = metadata;
-    }
-    if (record.compaction !== undefined) {
-        definition.compaction = normalizeAgentCompactionDefinition(record.compaction, message);
-    }
-    if (record.build !== undefined) {
-        definition.build = normalizeAgentBuildDefinition(record.build, message);
-    }
-    if (record.modelOptions !== undefined) {
-        definition.modelOptions = normalizeAgentModelOptions(record.modelOptions, message);
-    }
-    if (record.modelContextWindowTokens !== undefined) {
-        definition.modelContextWindowTokens = expectPositiveInteger(record.modelContextWindowTokens, message);
-    }
-    return definition;
-}
-function expectPositiveInteger(value, message) {
-    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-        throw new Error(message);
-    }
-    return value;
-}
-function normalizeAgentBuildDefinition(value, message) {
-    const record = expectObjectRecord(value, message);
-    expectOnlyKnownKeys(record, ["externalDependencies"], message);
-    const normalizedDefinition = {};
-    if (record.externalDependencies !== undefined) {
-        if (!Array.isArray(record.externalDependencies)) {
-            throw new Error(message);
-        }
-        normalizedDefinition.externalDependencies = Object.freeze(record.externalDependencies.map((entry) => expectString(entry, message)));
-    }
-    return normalizedDefinition;
-}
-function normalizeAgentModelOptions(value, message) {
-    const record = expectObjectRecord(value, message);
-    expectOnlyKnownKeys(record, ["providerOptions"], message);
-    const providerOptions = record.providerOptions;
-    if (providerOptions === undefined) {
-        return {};
-    }
-    return {
-        providerOptions: expectProviderOptions(providerOptions, message),
-    };
-}
-function normalizeAgentCompactionDefinition(value, message) {
-    const record = expectObjectRecord(value, message);
-    expectOnlyKnownKeys(record, ["model", "modelContextWindowTokens", "thresholdPercent"], message);
-    const normalizedDefinition = {};
-    if (record.model !== undefined) {
-        normalizedDefinition.model = record.model;
-    }
-    if (record.modelContextWindowTokens !== undefined) {
-        normalizedDefinition.modelContextWindowTokens = expectPositiveInteger(record.modelContextWindowTokens, message);
-    }
-    if (record.thresholdPercent !== undefined) {
-        const thresholdPercent = record.thresholdPercent;
-        if (typeof thresholdPercent !== "number" ||
-            !Number.isFinite(thresholdPercent) ||
-            thresholdPercent < 0 ||
-            thresholdPercent > 1) {
-            throw new Error(message);
-        }
-        normalizedDefinition.thresholdPercent = thresholdPercent;
-    }
-    return normalizedDefinition;
-}
-/**
- * Normalizes one authored instructions definition into the canonical
- * internal shape.
- *
- * Authored `name` fields are rejected — instructions prompt identity is
- * derived from the file path (`instructions.md` or
- * `instructions.{ts,...}`).
- */
-export function normalizeInstructionsDefinition(value, message) {
-    const record = expectObjectRecord(value, message);
-    expectOnlyKnownKeys(record, ["markdown"], message);
-    return {
-        markdown: expectString(record.markdown, message),
-    };
-}
-/**
- * Normalizes one authored skill definition into the canonical internal
- * shape.
- *
- * Authored `name` fields are rejected — skill identity is derived from
- * the file path under `agent/skills/`.
- */
-export function normalizeSkillDefinition(value, message) {
-    const record = expectObjectRecord(value, message);
-    expectOnlyKnownKeys(record, ["description", "files", "license", "markdown", "metadata"], message);
-    const definition = {
-        description: expectString(record.description, message),
-        markdown: expectString(record.markdown, message),
-    };
-    const license = record.license;
-    const metadata = getOptionalStringRecordProperty(record, "metadata", message);
-    if (license !== undefined) {
-        definition.license = expectString(license, message);
-    }
-    if (metadata !== undefined) {
-        definition.metadata = metadata;
-    }
-    if (record.files !== undefined) {
-        definition.files = normalizeSkillFiles(record.files, message);
-    }
-    return definition;
-}
-function normalizeSkillFiles(value, message) {
-    const files = expectObjectRecord(value, message);
-    const normalized = {};
-    for (const [filePath, content] of Object.entries(files)) {
-        if (typeof content === "string" || content instanceof Uint8Array) {
-            normalized[filePath] = content;
-            continue;
-        }
-        throw new Error(`${message} Expected skill file "${filePath}" to be a string or Uint8Array.`);
-    }
-    return normalized;
-}
-/**
- * Normalizes one authored schedule definition into the canonical internal
- * shape.
- *
- * Authored `name` fields are rejected — schedule identity is derived from
- * the file path under `agent/schedules/`. Exactly one of `markdown` (the
- * fire-and-forget agent prompt) or `run` (the cron handler function)
- * must be provided.
- */
-export function normalizeScheduleDefinition(value, message) {
-    const record = expectObjectRecord(value, message);
-    expectOnlyKnownKeys(record, ["cron", "markdown", "run"], message);
-    const cron = expectString(record.cron, message);
-    const hasMarkdown = record.markdown !== undefined;
-    const hasRun = record.run !== undefined;
-    if (hasMarkdown && hasRun) {
-        throw new Error(`${message} Pass either "markdown" (fire-and-forget) or "run" (handler) — not both.`);
-    }
-    if (!hasMarkdown && !hasRun) {
-        throw new Error(`${message} Must provide either "markdown" (fire-and-forget) or "run" (handler).`);
-    }
-    const definition = { cron };
-    if (hasMarkdown) {
-        definition.markdown = expectString(record.markdown, message);
-    }
-    else {
-        definition.run = expectFunction(record.run, message);
-    }
-    return definition;
-}
+import{expectFunction,expectObjectRecord,expectOnlyKnownKeys,expectProviderOptions,expectString,getOptionalStringRecordProperty}from"#internal/authored-module.js";function normalizeAgentDefinition(e,r){let o=expectObjectRecord(e,r);if(expectOnlyKnownKeys(o,[`build`,`compaction`,`description`,`metadata`,`model`,`modelContextWindowTokens`,`modelOptions`],r),o.model===void 0)throw Error(`${r} The "model" field is required.`);let s={model:o.model};o.description!==void 0&&(s.description=expectString(o.description,r));let c=getOptionalStringRecordProperty(o,`metadata`,r);return c!==void 0&&(s.metadata=c),o.compaction!==void 0&&(s.compaction=normalizeAgentCompactionDefinition(o.compaction,r)),o.build!==void 0&&(s.build=normalizeAgentBuildDefinition(o.build,r)),o.modelOptions!==void 0&&(s.modelOptions=normalizeAgentModelOptions(o.modelOptions,r)),o.modelContextWindowTokens!==void 0&&(s.modelContextWindowTokens=expectPositiveInteger(o.modelContextWindowTokens,r)),s}function expectPositiveInteger(e,t){if(typeof e!=`number`||!Number.isInteger(e)||e<=0)throw Error(t);return e}function normalizeAgentBuildDefinition(e,r){let a=expectObjectRecord(e,r);expectOnlyKnownKeys(a,[`externalDependencies`],r);let o={};if(a.externalDependencies!==void 0){if(!Array.isArray(a.externalDependencies))throw Error(r);o.externalDependencies=Object.freeze(a.externalDependencies.map(e=>expectString(e,r)))}return o}function normalizeAgentModelOptions(e,i){let a=expectObjectRecord(e,i);expectOnlyKnownKeys(a,[`providerOptions`],i);let o=a.providerOptions;return o===void 0?{}:{providerOptions:expectProviderOptions(o,i)}}function normalizeAgentCompactionDefinition(e,r){let i=expectObjectRecord(e,r);expectOnlyKnownKeys(i,[`model`,`modelContextWindowTokens`,`thresholdPercent`],r);let a={};if(i.model!==void 0&&(a.model=i.model),i.modelContextWindowTokens!==void 0&&(a.modelContextWindowTokens=expectPositiveInteger(i.modelContextWindowTokens,r)),i.thresholdPercent!==void 0){let e=i.thresholdPercent;if(typeof e!=`number`||!Number.isFinite(e)||e<0||e>1)throw Error(r);a.thresholdPercent=e}return a}function normalizeInstructionsDefinition(e,r){let a=expectObjectRecord(e,r);return expectOnlyKnownKeys(a,[`markdown`],r),{markdown:expectString(a.markdown,r)}}function normalizeSkillDefinition(e,r){let o=expectObjectRecord(e,r);expectOnlyKnownKeys(o,[`description`,`files`,`license`,`markdown`,`metadata`],r);let s={description:expectString(o.description,r),markdown:expectString(o.markdown,r)},c=o.license,l=getOptionalStringRecordProperty(o,`metadata`,r);return c!==void 0&&(s.license=expectString(c,r)),l!==void 0&&(s.metadata=l),o.files!==void 0&&(s.files=normalizeSkillFiles(o.files,r)),s}function normalizeSkillFiles(e,n){let r=expectObjectRecord(e,n),i={};for(let[e,t]of Object.entries(r)){if(typeof t==`string`||t instanceof Uint8Array){i[e]=t;continue}throw Error(`${n} Expected skill file "${e}" to be a string or Uint8Array.`)}return i}function normalizeScheduleDefinition(r,a){let o=expectObjectRecord(r,a);expectOnlyKnownKeys(o,[`cron`,`markdown`,`run`],a);let s=expectString(o.cron,a),c=o.markdown!==void 0,l=o.run!==void 0;if(c&&l)throw Error(`${a} Pass either "markdown" (fire-and-forget) or "run" (handler) — not both.`);if(!c&&!l)throw Error(`${a} Must provide either "markdown" (fire-and-forget) or "run" (handler).`);let u={cron:s};return c?u.markdown=expectString(o.markdown,a):u.run=expectFunction(o.run,a),u}export{normalizeAgentDefinition,normalizeInstructionsDefinition,normalizeScheduleDefinition,normalizeSkillDefinition};

package/dist/src/internal/authored-definition/sandbox.js

@@ -1,47 +1 @@
-import { expectFunction, expectObjectRecord, expectOnlyKnownKeys, } from "#internal/authored-module.js";
-import { lazyBackend } from "#execution/sandbox/lazy-backend.js";
-/**
- * Normalizes one authored sandbox definition into the canonical internal
- * shape. If the author supplied a `backend` callback (e.g.
- * `backend: () => vercelBackend({...})`), it is wrapped via
- * {@link lazyBackend} so downstream consumers always see a plain
- * `SandboxBackend` value — the callback fires exactly once on first
- * access and the resulting backend is memoized.
- */
-export function normalizeSandboxDefinition(value, message) {
-    const record = expectObjectRecord(value, message);
-    expectOnlyKnownKeys(record, ["backend", "bootstrap", "description", "onSession"], message);
-    const definition = {};
-    if (record.backend !== undefined) {
-        definition.backend = expectSandboxBackend(record.backend, message);
-    }
-    if (record.description !== undefined) {
-        if (typeof record.description !== "string") {
-            throw new Error(`${message} The "description" field must be a string when set.`);
-        }
-        definition.description = record.description;
-    }
-    if (record.bootstrap !== undefined) {
-        definition.bootstrap = expectFunction(record.bootstrap, message);
-    }
-    if (record.onSession !== undefined) {
-        definition.onSession = expectFunction(record.onSession, message);
-    }
-    return definition;
-}
-function expectSandboxBackend(value, message) {
-    if (typeof value === "function") {
-        return lazyBackend(value);
-    }
-    const record = expectObjectRecord(value, `${message} The "backend" field must be a SandboxBackend value (use vercelBackend(), localBackend(), or your own factory) or a zero-arg function returning one.`);
-    if (typeof record.name !== "string" || record.name.length === 0) {
-        throw new Error(`${message} The "backend" value must expose a non-empty string "name" identifier.`);
-    }
-    if (typeof record.create !== "function") {
-        throw new Error(`${message} The "backend" value must expose a "create" function.`);
-    }
-    if (record.prewarm !== undefined && typeof record.prewarm !== "function") {
-        throw new Error(`${message} The "backend.prewarm" property must be a function when set.`);
-    }
-    return record;
-}
+import{expectFunction,expectObjectRecord,expectOnlyKnownKeys}from"#internal/authored-module.js";import{lazyBackend}from"#execution/sandbox/lazy-backend.js";function normalizeSandboxDefinition(n,r){let i=expectObjectRecord(n,r);expectOnlyKnownKeys(i,[`backend`,`bootstrap`,`description`,`onSession`],r);let a={};if(i.backend!==void 0&&(a.backend=expectSandboxBackend(i.backend,r)),i.description!==void 0){if(typeof i.description!=`string`)throw Error(`${r} The "description" field must be a string when set.`);a.description=i.description}return i.bootstrap!==void 0&&(a.bootstrap=expectFunction(i.bootstrap,r)),i.onSession!==void 0&&(a.onSession=expectFunction(i.onSession,r)),a}function expectSandboxBackend(e,t){if(typeof e==`function`)return lazyBackend(e);let r=expectObjectRecord(e,`${t} The "backend" field must be a SandboxBackend value (use vercelBackend(), localBackend(), or your own factory) or a zero-arg function returning one.`);if(typeof r.name!=`string`||r.name.length===0)throw Error(`${t} The "backend" value must expose a non-empty string "name" identifier.`);if(typeof r.create!=`function`)throw Error(`${t} The "backend" value must expose a "create" function.`);if(r.prewarm!==void 0&&typeof r.prewarm!=`function`)throw Error(`${t} The "backend.prewarm" property must be a function when set.`);return r}export{normalizeSandboxDefinition};