experimental-ash 0.25.2 → 0.27.0

package/dist/src/services/dev-client/request-headers.js

@@ -1,197 +1 @@
-import { getVercelOidcToken } from "@vercel/oidc";
-import { ASH_ROUTE_PREFIX } from "#protocol/routes.js";
-const ASH_ROUTE_PREFIX_WITH_SEPARATOR = `${ASH_ROUTE_PREFIX}/`;
-/**
- * Hostnames the dev client treats as "local" for auth purposes. When the
- * target server is one of these, the dev client skips the Vercel OIDC
- * bearer entirely — the framework's default channel auth falls back to
- * `none()` off Vercel infrastructure, so attaching a bearer would be
- * wasted work and noise in the request inspector.
- */
-const LOCAL_HOSTNAMES = new Set([
-    "localhost",
-    "127.0.0.1",
-    "0.0.0.0",
-    "::1",
-    "[::1]",
-]);
-function isLocalAshServerUrl(url) {
-    return LOCAL_HOSTNAMES.has(url.hostname);
-}
-/**
- * Returns whether `serverUrl` targets one of the recognized local
- * development hostnames. Invalid URLs return `false` so callers can
- * always proceed as if the target is remote.
- */
-export function isLocalDevelopmentServerUrl(serverUrl) {
-    try {
-        return isLocalAshServerUrl(new URL(serverUrl));
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Resolves a Vercel OIDC token for the development client.
- *
- * Tries the `@vercel/oidc` SDK first (refreshes a freshly-issued token
- * when the CLI is linked to a Vercel project), then falls back to the
- * `VERCEL_OIDC_TOKEN` environment variable. Returns an empty string
- * when no token is available so callers can proceed without auth.
- */
-export async function resolveDevelopmentOidcToken() {
-    try {
-        const token = (await getVercelOidcToken()).trim();
-        if (token.length > 0) {
-            return token;
-        }
-    }
-    catch {
-        // Fall through to env var.
-    }
-    return process.env.VERCEL_OIDC_TOKEN?.trim() ?? "";
-}
-/**
- * Vercel header used to bypass preview protection for framework-owned routes
- * during local CLI development. Paired with a Protection Bypass for
- * Automation token issued from Project Settings.
- */
-export const VERCEL_PROTECTION_BYPASS_HEADER = "x-vercel-protection-bypass";
-/**
- * Vercel header used to bypass deployment protection by presenting a
- * trusted OIDC token issued by Vercel for the linked project. When the
- * CLI is `vercel link`-ed (or running inside a Vercel function), the
- * platform mints an OIDC token whose audience and subject match the
- * deployment, and accepts it as proof that the caller is authorized.
- *
- * This is preferred over {@link VERCEL_PROTECTION_BYPASS_HEADER} because
- * it requires no per-project secret — the token is already available via
- * `@vercel/oidc`.
- */
-export const VERCEL_TRUSTED_OIDC_IDP_TOKEN_HEADER = "x-vercel-trusted-oidc-idp-token";
-/**
- * Vercel request header that carries the runtime OIDC token on function
- * invocations.
- */
-export const VERCEL_OIDC_TOKEN_HEADER = "x-vercel-oidc-token";
-function isAshRouteUrl(url) {
-    return (url.pathname.endsWith(ASH_ROUTE_PREFIX) ||
-        url.pathname.includes(ASH_ROUTE_PREFIX_WITH_SEPARATOR));
-}
-/**
- * Creates request headers for one service-issued development request and
- * opportunistically refreshes a linked local Vercel OIDC token for Ash-owned
- * routes when no explicit authorization header is present.
- */
-export async function createDevelopmentRequestHeadersAsync(input) {
-    const headers = createBaseDevelopmentRequestHeaders(input);
-    const oidcToken = await resolveAshRouteOidcToken(headers, input.resourceUrl);
-    if (oidcToken !== null) {
-        attachAshRouteOidcHeaders(headers, oidcToken);
-    }
-    return headers;
-}
-function createBaseDevelopmentRequestHeaders(input) {
-    const headers = new Headers(resolveDevelopmentHeadersInit(input.headers));
-    const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();
-    if (bypassSecret && isAshRouteUrl(input.resourceUrl)) {
-        headers.set(VERCEL_PROTECTION_BYPASS_HEADER, bypassSecret);
-    }
-    return headers;
-}
-/**
- * Sets the authorization bearer and the trusted OIDC IDP bypass header
- * from a single resolved OIDC token. Authorization is left untouched if
- * the caller already set it explicitly; the bypass header is always
- * attached so deployment protection accepts the request even when the
- * caller picked their own bearer scheme (e.g. Basic auth on a preview).
- */
-function attachAshRouteOidcHeaders(headers, oidcToken) {
-    if (!headers.has("authorization")) {
-        headers.set("authorization", `Bearer ${oidcToken}`);
-    }
-    headers.set(VERCEL_TRUSTED_OIDC_IDP_TOKEN_HEADER, oidcToken);
-}
-/**
- * Resolves an OIDC token for an Ash-owned request, asking
- * `@vercel/oidc` for a freshly-issued token when the CLI is linked to a
- * Vercel project. Falls back to the forwarded runtime header or the
- * `VERCEL_OIDC_TOKEN` environment variable.
- */
-async function resolveAshRouteOidcToken(headers, resourceUrl) {
-    if (!shouldResolveAshRouteOidcToken(resourceUrl)) {
-        return null;
-    }
-    const requestToken = headers.get(VERCEL_OIDC_TOKEN_HEADER)?.trim();
-    if (requestToken) {
-        return requestToken;
-    }
-    return await resolveLocalDevelopmentOidcToken();
-}
-/**
- * Returns `true` when an Ash-route request should attempt to attach a
- * Vercel OIDC token. Local dev servers do not need (and cannot validate)
- * the token, so this returns `false` for them.
- */
-function shouldResolveAshRouteOidcToken(resourceUrl) {
-    if (!isAshRouteUrl(resourceUrl)) {
-        return false;
-    }
-    // The framework's default HTTP channels fall back to `none()` off
-    // Vercel infrastructure (see runtime/framework-channels/index.ts), so
-    // attaching a bearer or bypass token to a localhost request is wasted
-    // work and noise in the request inspector.
-    if (isLocalAshServerUrl(resourceUrl)) {
-        return false;
-    }
-    return true;
-}
-async function resolveLocalDevelopmentOidcToken() {
-    const token = await resolveDevelopmentOidcToken();
-    return token.length > 0 ? token : null;
-}
-function resolveDevelopmentHeadersInit(headers) {
-    if (headers === undefined) {
-        return undefined;
-    }
-    if (headers instanceof Headers) {
-        return headers;
-    }
-    if (Array.isArray(headers)) {
-        return headers.map(([key, value]) => [key, value]);
-    }
-    return headers;
-}
-/**
- * Resolves the per-request custom headers used by the development client
- * when constructing requests against a configured server URL.
- *
- * - {@link VERCEL_PROTECTION_BYPASS_HEADER} is attached when
- *   `VERCEL_AUTOMATION_BYPASS_SECRET` is set.
- * - {@link VERCEL_TRUSTED_OIDC_IDP_TOKEN_HEADER} is attached when a Vercel
- *   OIDC token is available locally (either via `vercel link` +
- *   `@vercel/oidc` or via the `VERCEL_OIDC_TOKEN` environment variable).
- *   This lets the CLI bypass Vercel Deployment Protection without the user
- *   creating a project-scoped Bypass for Automation token first.
- *
- * Both headers are sent when both sources are available; the platform
- * accepts whichever it can validate.
- *
- * Local dev servers skip the OIDC token entirely — the framework's
- * default channel auth falls back to `none()` off Vercel infrastructure,
- * so attaching the bypass token would be wasted work.
- */
-export async function resolveDevelopmentClientHeaders(input) {
-    const headers = {};
-    const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();
-    if (bypassSecret) {
-        headers[VERCEL_PROTECTION_BYPASS_HEADER] = bypassSecret;
-    }
-    if (!isLocalDevelopmentServerUrl(input.serverUrl)) {
-        const oidcToken = await resolveDevelopmentOidcToken();
-        if (oidcToken.length > 0) {
-            headers[VERCEL_TRUSTED_OIDC_IDP_TOKEN_HEADER] = oidcToken;
-        }
-    }
-    return headers;
-}
+import{ASH_ROUTE_PREFIX}from"#protocol/routes.js";import{getVercelOidcToken}from"#compiled/@vercel/oidc/index.js";var ASH_ROUTE_PREFIX_WITH_SEPARATOR=`${ASH_ROUTE_PREFIX}/`,LOCAL_HOSTNAMES=new Set([`localhost`,`127.0.0.1`,`0.0.0.0`,`::1`,`[::1]`]);function isLocalAshServerUrl(e){return LOCAL_HOSTNAMES.has(e.hostname)}function isLocalDevelopmentServerUrl(e){try{return isLocalAshServerUrl(new URL(e))}catch{return!1}}async function resolveDevelopmentOidcToken(){try{let e=(await getVercelOidcToken()).trim();if(e.length>0)return e}catch{}return process.env.VERCEL_OIDC_TOKEN?.trim()??``}var VERCEL_PROTECTION_BYPASS_HEADER=`x-vercel-protection-bypass`,VERCEL_TRUSTED_OIDC_IDP_TOKEN_HEADER=`x-vercel-trusted-oidc-idp-token`,VERCEL_OIDC_TOKEN_HEADER=`x-vercel-oidc-token`;function isAshRouteUrl(t){return t.pathname.endsWith(ASH_ROUTE_PREFIX)||t.pathname.includes(ASH_ROUTE_PREFIX_WITH_SEPARATOR)}async function createDevelopmentRequestHeadersAsync(e){let t=createBaseDevelopmentRequestHeaders(e),n=await resolveAshRouteOidcToken(t,e.resourceUrl);return n!==null&&attachAshRouteOidcHeaders(t,n),t}function createBaseDevelopmentRequestHeaders(e){let t=new Headers(resolveDevelopmentHeadersInit(e.headers)),n=process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();return n&&isAshRouteUrl(e.resourceUrl)&&t.set(VERCEL_PROTECTION_BYPASS_HEADER,n),t}function attachAshRouteOidcHeaders(e,t){e.has(`authorization`)||e.set(`authorization`,`Bearer ${t}`),e.set(VERCEL_TRUSTED_OIDC_IDP_TOKEN_HEADER,t)}async function resolveAshRouteOidcToken(e,t){return shouldResolveAshRouteOidcToken(t)?e.get(VERCEL_OIDC_TOKEN_HEADER)?.trim()||await resolveLocalDevelopmentOidcToken():null}function shouldResolveAshRouteOidcToken(e){return!(!isAshRouteUrl(e)||isLocalAshServerUrl(e))}async function resolveLocalDevelopmentOidcToken(){let e=await resolveDevelopmentOidcToken();return e.length>0?e:null}function resolveDevelopmentHeadersInit(e){if(e!==void 0)return e instanceof Headers?e:Array.isArray(e)?e.map(([e,t])=>[e,t]):e}async function resolveDevelopmentClientHeaders(e){let t={},n=process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();if(n&&(t[VERCEL_PROTECTION_BYPASS_HEADER]=n),!isLocalDevelopmentServerUrl(e.serverUrl)){let e=await resolveDevelopmentOidcToken();e.length>0&&(t[VERCEL_TRUSTED_OIDC_IDP_TOKEN_HEADER]=e)}return t}export{VERCEL_OIDC_TOKEN_HEADER,VERCEL_PROTECTION_BYPASS_HEADER,VERCEL_TRUSTED_OIDC_IDP_TOKEN_HEADER,createDevelopmentRequestHeadersAsync,isLocalDevelopmentServerUrl,resolveDevelopmentClientHeaders,resolveDevelopmentOidcToken};

package/dist/src/services/dev-client/stream.js

@@ -1,7 +1 @@
-import { isCurrentTurnBoundaryEvent } from "#protocol/message.js";
-/**
- * Returns the last boundary event observed for the current streamed turn slice.
- */
-export function extractCurrentTurnBoundaryEvent(events) {
-    return [...events].reverse().find(isCurrentTurnBoundaryEvent);
-}
+import{isCurrentTurnBoundaryEvent}from"#protocol/message.js";function extractCurrentTurnBoundaryEvent(e){return[...e].reverse().find(isCurrentTurnBoundaryEvent)}export{extractCurrentTurnBoundaryEvent};

package/dist/src/services/dev-client/url.js

@@ -1,25 +1 @@
-function createDevelopmentServerBaseUrl(serverUrl) {
-    const url = new URL(serverUrl);
-    url.hash = "";
-    url.search = "";
-    if (!url.pathname.endsWith("/")) {
-        url.pathname = `${url.pathname}/`;
-    }
-    return url;
-}
-/**
- * Resolves one server-provided resource reference against the configured
- * development server URL.
- *
- * Absolute resource URLs are returned untouched; relative routes are
- * resolved against the development server base.
- */
-export function resolveDevelopmentServerResourceUrl(input) {
-    const resource = input.resource.trim();
-    try {
-        return new URL(resource);
-    }
-    catch {
-        return new URL(resource.replace(/^\/+/, ""), createDevelopmentServerBaseUrl(input.serverUrl));
-    }
-}
+function createDevelopmentServerBaseUrl(e){let t=new URL(e);return t.hash=``,t.search=``,t.pathname.endsWith(`/`)||(t.pathname=`${t.pathname}/`),t}function resolveDevelopmentServerResourceUrl(e){let t=e.resource.trim();try{return new URL(t)}catch{return new URL(t.replace(/^\/+/,``),createDevelopmentServerBaseUrl(e.serverUrl))}}export{resolveDevelopmentServerResourceUrl};

package/dist/src/services/dev-client/vercel-auth-error.js

@@ -1,98 +1,2 @@
-/**
- * Detection and rendering helpers for the Vercel Deployment Protection
- * "Authentication Required" challenge that fronts protected previews and
- * production deployments.
- *
- * When the Ash development client (`ash dev --url …`) targets a deployment
- * that has Deployment Protection enabled and no valid bypass header is
- * attached, Vercel returns an HTML SSO challenge instead of routing the
- * request to the function. The raw HTML body is unhelpful in a CLI
- * context — it dumps a multi-kilobyte page where a one-line directive
- * would do.
- *
- * These helpers let the REPL detect the challenge and render a focused,
- * actionable message instead.
- */
-import { ClientError } from "#client/client-error.js";
-/**
- * Substrings that uniquely identify the Vercel Deployment Protection
- * SSO challenge page. The page is generated server-side by Vercel and
- * its markup includes a stable `<title>` plus the SSO redirect URL.
- *
- * Substring matching (rather than parsing the HTML) is intentional:
- * the page changes shape over time but these tokens have remained
- * stable, and a forgiving matcher keeps `ash dev` resilient when
- * minor markup tweaks ship.
- */
-const VERCEL_AUTH_CHALLENGE_MARKERS = [
-    "vercel.com/sso-api",
-    "<title>Authentication Required</title>",
-    "Vercel Authentication",
-];
-/**
- * Heuristic: returns `true` when the response body looks like a
- * Vercel Deployment Protection SSO challenge.
- *
- * Matching is substring-based against {@link VERCEL_AUTH_CHALLENGE_MARKERS}
- * so the CLI keeps degrading gracefully when Vercel tweaks the page.
- */
-function bodyLooksLikeVercelAuthChallenge(body) {
-    if (body.length === 0) {
-        return false;
-    }
-    for (const marker of VERCEL_AUTH_CHALLENGE_MARKERS) {
-        if (body.includes(marker)) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Returns `true` when the thrown error is the Vercel Deployment
- * Protection SSO challenge.
- *
- * Accepts both real {@link ClientError} instances and structurally
- * compatible duck-typed errors (`{ status: number, body: string }`)
- * so callers can detect the challenge regardless of whether the
- * error survived a network/IPC boundary.
- *
- * Exported so the dev REPL and other dev-client consumers can render
- * a focused authentication directive instead of dumping the SSO
- * challenge HTML to the terminal.
- */
-export function isVercelAuthChallenge(error) {
-    if (error instanceof ClientError) {
-        return bodyLooksLikeVercelAuthChallenge(error.body);
-    }
-    if (error !== null &&
-        typeof error === "object" &&
-        "body" in error &&
-        typeof error.body === "string") {
-        return bodyLooksLikeVercelAuthChallenge(error.body);
-    }
-    return false;
-}
-/**
- * Builds the human-readable message rendered when
- * {@link isVercelAuthChallenge} returns `true`.
- *
- * The message states the cause, the target URL, and the supported escape
- * hatches (link the project so an OIDC token can be minted, set an
- * automation bypass token, or disable protection). It is intentionally
- * short — multi-line CLI output is harder to scan than a focused
- * directive.
- */
-export function formatVercelAuthChallengeMessage(input) {
-    return [
-        `Vercel Deployment Protection blocked the request to ${input.serverUrl}.`,
-        "",
-        "To access the deployment from `ash dev`, do one of:",
-        "  • Run `vercel link` in this project so the CLI can mint an OIDC",
-        "    token for the deployment automatically.",
-        "  • Set VERCEL_AUTOMATION_BYPASS_SECRET to a Protection Bypass for",
-        "    Automation token (Project Settings → Deployment Protection).",
-        "  • Disable Deployment Protection on the target deployment.",
-        "",
-        "Docs: https://vercel.com/docs/deployment-protection",
-    ].join("\n");
-}
+import{ClientError}from"#client/client-error.js";var VERCEL_AUTH_CHALLENGE_MARKERS=[`vercel.com/sso-api`,`<title>Authentication Required</title>`,`Vercel Authentication`];function bodyLooksLikeVercelAuthChallenge(e){if(e.length===0)return!1;for(let n of VERCEL_AUTH_CHALLENGE_MARKERS)if(e.includes(n))return!0;return!1}function isVercelAuthChallenge(t){return t instanceof ClientError||typeof t==`object`&&t&&`body`in t&&typeof t.body==`string`?bodyLooksLikeVercelAuthChallenge(t.body):!1}function formatVercelAuthChallengeMessage(e){return[`Vercel Deployment Protection blocked the request to ${e.serverUrl}.`,``,"To access the deployment from `ash dev`, do one of:","  • Run `vercel link` in this project so the CLI can mint an OIDC",`    token for the deployment automatically.`,`  • Set VERCEL_AUTOMATION_BYPASS_SECRET to a Protection Bypass for`,`    Automation token (Project Settings → Deployment Protection).`,`  • Disable Deployment Protection on the target deployment.`,``,`Docs: https://vercel.com/docs/deployment-protection`].join(`
+`)}export{formatVercelAuthChallengeMessage,isVercelAuthChallenge};

package/dist/src/services/dev-client.js

@@ -1,48 +1 @@
-import { Client } from "#client/index.js";
-import { isLocalDevelopmentServerUrl, resolveDevelopmentClientHeaders, resolveDevelopmentOidcToken, } from "#services/dev-client/request-headers.js";
-class BufferedDevelopmentMessageClient {
-    #client;
-    #session;
-    constructor(input) {
-        const isLocal = isLocalDevelopmentServerUrl(input.serverUrl);
-        const clientOptions = {
-            headers: () => resolveDevelopmentClientHeaders({ serverUrl: input.serverUrl }),
-            host: input.serverUrl,
-        };
-        this.#client = new Client(isLocal ? clientOptions : { ...clientOptions, auth: { bearer: resolveDevelopmentOidcToken } });
-        this.#session = this.#client.session();
-    }
-    async clear() {
-        this.#session = this.#client.session();
-    }
-    async close() {
-        // No resources to dispose.
-    }
-    getSession() {
-        return this.#session.state;
-    }
-    async send(input) {
-        const res = await this.#session.send({
-            clientContext: input.clientContext,
-            inputResponses: input.inputResponses,
-            message: input.message,
-        });
-        input.onResponseStart?.({ sessionId: res.sessionId });
-        const events = [];
-        for await (const event of res) {
-            events.push(event);
-            input.onEvent?.(event);
-        }
-        return {
-            events,
-            sessionId: res.sessionId,
-            session: this.#session.state,
-        };
-    }
-}
-/**
- * Creates a stateful development client bound to one Ash server URL.
- */
-export function createDevClient(input) {
-    return new BufferedDevelopmentMessageClient(input);
-}
+import{isLocalDevelopmentServerUrl,resolveDevelopmentClientHeaders,resolveDevelopmentOidcToken}from"#services/dev-client/request-headers.js";import{Client}from"#client/index.js";var BufferedDevelopmentMessageClient=class{#e;#t;constructor(i){let a=isLocalDevelopmentServerUrl(i.serverUrl),o={headers:()=>resolveDevelopmentClientHeaders({serverUrl:i.serverUrl}),host:i.serverUrl};this.#e=new Client(a?o:{...o,auth:{bearer:resolveDevelopmentOidcToken}}),this.#t=this.#e.session()}async clear(){this.#t=this.#e.session()}async close(){}getSession(){return this.#t.state}async send(e){let t=await this.#t.send({clientContext:e.clientContext,inputResponses:e.inputResponses,message:e.message});e.onResponseStart?.({sessionId:t.sessionId});let n=[];for await(let r of t)n.push(r),e.onEvent?.(r);return{events:n,sessionId:t.sessionId,session:this.#t.state}}};function createDevClient(e){return new BufferedDevelopmentMessageClient(e)}export{createDevClient};

package/dist/src/services/inspect-application.js

@@ -1,45 +1 @@
-import { CompileAgentError, compileAgent, } from "#compiler/compile-agent.js";
-import { MissingAgentConfigModuleError } from "#compiler/normalize-agent-config.js";
-import { DiscoveryProjectResolutionError } from "#discover/project.js";
-import { getApplicationInfo } from "#internal/application/paths.js";
-import { ASH_CREATE_SESSION_ROUTE_PATH, ASH_CONTINUE_SESSION_ROUTE_PATTERN, ASH_MESSAGE_STREAM_ROUTE_PATTERN, } from "#protocol/routes.js";
-/**
- * Resolves application details, compile artifacts, and the active message
- * contract for one Ash application root.
- */
-export async function inspectApplication(appRoot) {
-    const compiledState = await loadCompiledApplicationState(appRoot);
-    const application = getApplicationInfo(compiledState?.project.appRoot ?? appRoot);
-    return {
-        application,
-        compiledState,
-        messaging: {
-            createSessionRoutePath: ASH_CREATE_SESSION_ROUTE_PATH,
-            continueSessionRoutePattern: ASH_CONTINUE_SESSION_ROUTE_PATTERN,
-            streamRoutePattern: ASH_MESSAGE_STREAM_ROUTE_PATTERN,
-        },
-    };
-}
-async function loadCompiledApplicationState(appRoot) {
-    try {
-        return await compileAgent({
-            startPath: appRoot,
-        });
-    }
-    catch (error) {
-        if (error instanceof CompileAgentError) {
-            return error.result;
-        }
-        if (error instanceof DiscoveryProjectResolutionError) {
-            return null;
-        }
-        // The `info` command runs from arbitrary directories. When discovery
-        // happens to resolve a project marker but the directory is not actually
-        // an Ash application (no `agent.ts`), surface the inspection without a
-        // compiled state instead of failing the entire command.
-        if (error instanceof MissingAgentConfigModuleError) {
-            return null;
-        }
-        throw error;
-    }
-}
+import{ASH_CONTINUE_SESSION_ROUTE_PATTERN,ASH_CREATE_SESSION_ROUTE_PATH,ASH_MESSAGE_STREAM_ROUTE_PATTERN}from"#protocol/routes.js";import{getApplicationInfo}from"#internal/application/paths.js";import{DiscoveryProjectResolutionError}from"#discover/project.js";import{MissingAgentConfigModuleError}from"#compiler/normalize-agent-config.js";import{CompileAgentError,compileAgent}from"#compiler/compile-agent.js";async function inspectApplication(t){let n=await loadCompiledApplicationState(t);return{application:getApplicationInfo(n?.project.appRoot??t),compiledState:n,messaging:{createSessionRoutePath:ASH_CREATE_SESSION_ROUTE_PATH,continueSessionRoutePattern:ASH_CONTINUE_SESSION_ROUTE_PATTERN,streamRoutePattern:ASH_MESSAGE_STREAM_ROUTE_PATTERN}}}async function loadCompiledApplicationState(e){try{return await compileAgent({startPath:e})}catch(e){if(e instanceof CompileAgentError)return e.result;if(e instanceof DiscoveryProjectResolutionError||e instanceof MissingAgentConfigModuleError)return null;throw e}}export{inspectApplication};

package/dist/src/shared/agent-definition.js

@@ -1 +1 @@
-export {};
+export{};

package/dist/src/shared/errors.js

@@ -1,66 +1 @@
-/**
- * Shared pure error projections used by public helpers and internals.
- */
-import { isObject } from "#shared/guards.js";
-/**
- * Projects an unknown throwable into a human-readable string.
- *
- * Plain objects are rendered as JSON rather than `"[object Object]"`.
- */
-export function toErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    if (typeof error === "string") {
-        return error;
-    }
-    if (error === null || error === undefined) {
-        return String(error);
-    }
-    if (isObject(error)) {
-        if (typeof error.message === "string" && error.message.length > 0) {
-            return error.message;
-        }
-        return safeJsonStringify(error);
-    }
-    return String(error);
-}
-/**
- * Coerces an unknown throwable into a proper {@link Error} instance.
- *
- * Returns real Errors unchanged. For plain-object shapes (common after
- * structured-clone strips prototypes), copies useful `message`, `name`,
- * `stack`, and `cause` fields onto a fresh Error.
- */
-export function toError(raw) {
-    if (raw instanceof Error) {
-        return raw;
-    }
-    const error = new Error(toErrorMessage(raw));
-    if (!isObject(raw)) {
-        return error;
-    }
-    if (typeof raw.name === "string" && raw.name.length > 0) {
-        error.name = raw.name;
-    }
-    if (typeof raw.stack === "string" && raw.stack.length > 0) {
-        error.stack = raw.stack;
-    }
-    if ("cause" in raw && raw.cause !== undefined && raw.cause !== raw) {
-        error.cause = raw.cause;
-    }
-    return error;
-}
-function safeJsonStringify(value) {
-    try {
-        const stringified = JSON.stringify(value);
-        // `JSON.stringify` returns `undefined` for values whose top-level
-        // reduces to `undefined` (functions, symbols, undefined itself).
-        // Fall back so callers never receive a literal `"undefined"` that
-        // they cannot tell apart from the real primitive.
-        return stringified ?? String(value);
-    }
-    catch {
-        return String(value);
-    }
-}
+import{isObject}from"#shared/guards.js";function toErrorMessage(t){return t instanceof Error?t.message:typeof t==`string`?t:t==null?String(t):isObject(t)?typeof t.message==`string`&&t.message.length>0?t.message:safeJsonStringify(t):String(t)}function toError(t){if(t instanceof Error)return t;let n=Error(toErrorMessage(t));return isObject(t)?(typeof t.name==`string`&&t.name.length>0&&(n.name=t.name),typeof t.stack==`string`&&t.stack.length>0&&(n.stack=t.stack),`cause`in t&&t.cause!==void 0&&t.cause!==t&&(n.cause=t.cause),n):n}function safeJsonStringify(e){try{return JSON.stringify(e)??String(e)}catch{return String(e)}}export{toError,toErrorMessage};

package/dist/src/shared/guards.js

@@ -1,35 +1 @@
-/**
- * Small, unavoidable type guards used across the framework.
- *
- * Before adding a new guard: check whether `shared/json.ts`,
- * `shared/optional.ts`, or an existing standard-library predicate
- * already covers the case. This module exists specifically to stop
- * the same 3-line `typeof x === "object" && x !== null` pattern from
- * proliferating in every file that duck-types a field off an
- * `unknown` value.
- */
-/**
- * Returns `true` when `value` is a non-null object that is not an
- * `Array`. Refines the type to `Record<string, unknown>` so callers
- * can duck-type fields without a subsequent `as { foo?: unknown }`
- * cast.
- *
- * Arrays are excluded because every use site in the codebase is
- * reading named fields (`value.message`, `value.errorId`,
- * `value.kind`, etc.) — none of which are meaningful on an array. If
- * you need "any non-null object including arrays", use
- * `typeof value === "object" && value !== null` inline.
- */
-export function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
- * Returns `true` when `value` is a string with at least one
- * character. The zero-length check matters: empty strings routinely
- * fall out of optional-field projections (Slack `team_id`, HTTP
- * headers, JSON parse results) and should not be treated as a
- * meaningful value by display or correlation logic.
- */
-export function isNonEmptyString(value) {
-    return typeof value === "string" && value.length > 0;
-}
+function isObject(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function isNonEmptyString(e){return typeof e==`string`&&e.length>0}export{isNonEmptyString,isObject};

package/dist/src/shared/json-schemas.js

@@ -1,41 +1 @@
-import { z } from "#compiled/zod/index.js";
-import { parseJsonObject, parseJsonValue } from "#shared/json.js";
-const JSON_VALUE_ERROR_MESSAGE = "Expected a JSON-serializable value.";
-const JSON_OBJECT_ERROR_MESSAGE = "Expected a JSON-serializable object.";
-/**
- * Zod schema for JSON-serializable values.
- */
-export const jsonValueSchema = z
-    .unknown()
-    .transform((value, ctx) => {
-    try {
-        return parseJsonValue(value);
-    }
-    catch (error) {
-        ctx.addIssue({
-            code: "custom",
-            message: formatJsonParseError(error, JSON_VALUE_ERROR_MESSAGE),
-        });
-        return z.NEVER;
-    }
-});
-/**
- * Zod schema for JSON-serializable object values.
- */
-export const jsonObjectSchema = z
-    .unknown()
-    .transform((value, ctx) => {
-    try {
-        return parseJsonObject(value);
-    }
-    catch (error) {
-        ctx.addIssue({
-            code: "custom",
-            message: formatJsonParseError(error, JSON_OBJECT_ERROR_MESSAGE),
-        });
-        return z.NEVER;
-    }
-});
-function formatJsonParseError(error, fallback) {
-    return error instanceof Error ? error.message : fallback;
-}
+import{z}from"#compiled/zod/index.js";import{parseJsonObject,parseJsonValue}from"#shared/json.js";var JSON_VALUE_ERROR_MESSAGE=`Expected a JSON-serializable value.`,JSON_OBJECT_ERROR_MESSAGE=`Expected a JSON-serializable object.`,jsonValueSchema=z.unknown().transform((t,i)=>{try{return parseJsonValue(t)}catch(t){return i.addIssue({code:`custom`,message:formatJsonParseError(t,JSON_VALUE_ERROR_MESSAGE)}),z.NEVER}}),jsonObjectSchema=z.unknown().transform((n,r)=>{try{return parseJsonObject(n)}catch(t){return r.addIssue({code:`custom`,message:formatJsonParseError(t,JSON_OBJECT_ERROR_MESSAGE)}),z.NEVER}});function formatJsonParseError(e,t){return e instanceof Error?e.message:t}export{jsonObjectSchema,jsonValueSchema};