@sanity/runtime-cli 17.15.0 → 17.16.0-app-functions.gab0267c

package/dist/config.d.ts

@@ -1,7 +1,6 @@
 export declare const BLUEPRINT_CONFIG_VERSION = "v2025-05-08";
 export declare const BLUEPRINTS_API_VERSION: string;
-export declare const BLUEPRINT_CONFIG_DIR = ".sanity";
-export declare const BLUEPRINT_CONFIG_FILE = "blueprint.config.json";
+export { STACK_CONFIG_DIR as BLUEPRINT_CONFIG_DIR, STACK_CONFIG_FILE as BLUEPRINT_CONFIG_FILE, } from '@sanity/blueprints/resolve';
 export declare const RUNTIME_CLI_NAME = "@sanity/runtime-cli";
 export declare let RUNTIME_CLI_VERSION: string | undefined;
 export declare const RUNTIME_CLI_USER_AGENT: string;

package/dist/config.js

@@ -8,8 +8,7 @@ export const BLUEPRINT_CONFIG_VERSION = 'v2025-05-08';
 // Default API version for Blueprints service calls.
 // Overridable globally via env, or per-endpoint via the `version` arg to `blueprintsUrl`.
 export const BLUEPRINTS_API_VERSION = env.SANITY_BLUEPRINTS_API_VERSION ?? 'v2026-06-15';
-export const BLUEPRINT_CONFIG_DIR = '.sanity';
-export const BLUEPRINT_CONFIG_FILE = 'blueprint.config.json';
+export { STACK_CONFIG_DIR as BLUEPRINT_CONFIG_DIR, STACK_CONFIG_FILE as BLUEPRINT_CONFIG_FILE, } from '@sanity/blueprints/resolve';
 export const RUNTIME_CLI_NAME = '@sanity/runtime-cli';
 export let RUNTIME_CLI_VERSION;
 try {

package/dist/cores/blueprints/deploy.d.ts

@@ -1,3 +1,4 @@
+import type { BlueprintResource } from '@sanity/blueprints';
 import type { ReadBlueprintResult } from '../../actions/blueprints/blueprint.js';
 import type { AuthParams, ScopeType, Stack } from '../../utils/types.js';
 import type { CoreConfig, CoreResult } from '../index.js';
@@ -19,3 +20,10 @@ export interface BlueprintDeployOptions extends CoreConfig {
     };
 }
 export declare function blueprintDeployCore(options: BlueprintDeployOptions): Promise<CoreResult>;
+export interface ResourceDeployOptions extends Omit<BlueprintDeployOptions, 'blueprint'> {
+    resources: BlueprintResource[];
+    workDir: string;
+    fetchFn?: typeof fetch;
+}
+/** Deploy an in-memory resource list using the same pipeline as a Blueprint file. */
+export declare function deployResourcesCore(options: ResourceDeployOptions): Promise<CoreResult>;

package/dist/cores/blueprints/deploy.js

@@ -14,16 +14,23 @@ import { styleText } from '../../utils/style-text.js';
 import { createTracedFetch } from '../../utils/traced-fetch.js';
 import { getWarnings } from '../../utils/warnings.js';
 export async function blueprintDeployCore(options) {
-    const { bin = 'sanity', log: logger, auth, stackId, scopeType, scopeId, deployedStack, blueprint, cliVersion, flags, } = options;
+    return deployResourcesCore({
+        ...options,
+        resources: options.blueprint.resources,
+        workDir: dirname(options.blueprint.fileInfo.blueprintFilePath),
+    });
+}
+/** Deploy an in-memory resource list using the same pipeline as a Blueprint file. */
+export async function deployResourcesCore(options) {
+    const { bin = 'sanity', log: logger, auth, stackId, scopeType, scopeId, deployedStack, workDir: blueprintFileDir, cliVersion, flags, } = options;
     const { verbose } = flags;
     const noWait = flags['no-wait'] || false;
     const stackName = flags['new-stack-name'] ?? deployedStack.name;
     const installer = flags['fn-installer'] || undefined;
-    const blueprintFileDir = dirname(blueprint.fileInfo.blueprintFilePath);
     const workspaceWarnings = getWarnings({ dir: blueprintFileDir });
     logger(`Deploying "${stackName}" ${niceId(deployedStack.id)}...`);
     try {
-        const fetchFn = createTracedFetch(logger);
+        const fetchFn = options.fetchFn ?? createTracedFetch(logger);
         const { ok: checkOk, stack: currentStack } = await getStack({ stackId, auth, fetchFn });
         if (!checkOk) {
             return { success: false, error: 'Failed to check current Stack status' };
@@ -39,7 +46,7 @@ export async function blueprintDeployCore(options) {
                 ],
             };
         }
-        const resources = [...blueprint.resources];
+        const resources = [...options.resources];
         let spinner;
         const preDeployResult = await preDeploy({
             scopeType,
@@ -143,6 +150,7 @@ export async function blueprintDeployCore(options) {
             bin,
             verbose,
             progressNoun: 'deployment',
+            fetchFn,
         });
         if (outcome.type === 'completed') {
             logger(styleText(['bold', 'green'], 'Stack deployment completed!'));

package/dist/cores/blueprints/destroy.d.ts

@@ -1,5 +1,5 @@
 import { type LocatedBlueprintsConfig } from '../../actions/blueprints/config.js';
-import type { ScopeType } from '../../utils/types.js';
+import type { AuthParams, ScopeType } from '../../utils/types.js';
 import type { CoreConfig, CoreResult } from '../index.js';
 export interface BlueprintDestroyOptions extends CoreConfig {
     token: string;
@@ -20,3 +20,16 @@ export interface BlueprintDestroyOptions extends CoreConfig {
     };
 }
 export declare function blueprintDestroyCore(options: BlueprintDestroyOptions): Promise<CoreResult>;
+type WaitForDestructionOptions = {
+    stackId: string;
+    stackName: string;
+    operationId: string;
+    requestId?: string;
+    auth: AuthParams;
+    log: CoreConfig['log'];
+    bin: string;
+    verbose?: boolean;
+    fetchFn?: typeof fetch;
+};
+export declare function waitForDestruction(options: WaitForDestructionOptions): Promise<CoreResult>;
+export {};

package/dist/cores/blueprints/destroy.js

@@ -150,7 +150,7 @@ function afterDestroyAccepted(options) {
     }
     return waitForDestruction(options);
 }
-async function waitForDestruction(options) {
+export async function waitForDestruction(options) {
     const { stackId, stackName, operationId, requestId, auth, log, bin, verbose = false } = options;
     log(styleText('dim', 'Stack destruction progress:'));
     log('');
@@ -163,6 +163,7 @@ async function waitForDestruction(options) {
         verbose,
         includeDestroyed: true,
         progressNoun: 'destruction',
+        fetchFn: options.fetchFn,
     });
     if (outcome.type === 'completed') {
         log(styleText(['bold', 'magenta'], 'Stack destruction completed!'));

package/dist/cores/blueprints/doctor.js

@@ -1,11 +1,11 @@
 import { readFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { arch, cwd, env, version as nodeVersion, platform } from 'node:process';
+import { resolveStackConfig } from '@sanity/blueprints/resolve';
 import { formatDateTime } from '@sanity/cli-core/dates';
 import * as resolve from 'empathic/resolve';
 import { loadAndParseBlueprint, } from '../../actions/blueprints/blueprint.js';
 import { readConfigFile } from '../../actions/blueprints/config.js';
-import { resolveIds } from '../../actions/blueprints/resolve.js';
 import { getStack } from '../../actions/blueprints/stacks.js';
 import config, { RUNTIME_CLI_VERSION } from '../../config.js';
 import { presentBlueprintParserErrors } from '../../utils/display/errors.js';
@@ -92,7 +92,7 @@ export async function blueprintDoctorCore(options) {
             validateResources: options.validateResources || false,
         });
         const blueprintConfig = readConfigFile(blueprint.fileInfo.blueprintFilePath);
-        const resolved = resolveIds({
+        const resolved = resolveStackConfig({
             module: blueprint.module,
             config: blueprintConfig,
         });

package/dist/cores/blueprints/init.js

@@ -125,6 +125,16 @@ async function handleExistingBlueprint(options) {
             error: 'Flag --example cannot be used with an existing Blueprint.',
         };
     }
+    const existingBlueprint = await readLocalBlueprint(log, { resources: validateResources || false }, existingBlueprintFile.blueprintFilePath);
+    const hasStack = Boolean(existingBlueprint.blueprintConfig?.stackId);
+    if (hasStack) {
+        const overwrite = await confirm({
+            message: 'This Blueprint has an existing Stack. Are you sure you want to re-initialize?',
+            default: true,
+        });
+        if (!overwrite)
+            return { success: false, error: 'Initialization cancelled.' };
+    }
     // --stack-name with a scope flag means create a new stack before configuring
     let resolvedStackId = flagStackId;
     if (!resolvedStackId && flagStackName) {
@@ -142,7 +152,7 @@ async function handleExistingBlueprint(options) {
     }
     // unknown intent, prompt for confirmation
     const flagProvidedConfig = [flagProjectId, flagOrganizationId, flagStackId].some(Boolean);
-    if (!flagProvidedConfig && !flagStackName) {
+    if (!flagProvidedConfig && !hasStack && !flagStackName) {
         const overwrite = await confirm({
             message: "This Blueprint doesn't have a deployment Stack yet. Configure one now?",
             default: true,
@@ -150,7 +160,6 @@ async function handleExistingBlueprint(options) {
         if (!overwrite)
             return { success: false, error: 'Initialization cancelled.' };
     }
-    const existingBlueprint = await readLocalBlueprint(log, { resources: validateResources || false }, existingBlueprintFile.blueprintFilePath);
     return blueprintConfigCore({
         blueprint: existingBlueprint,
         bin,

package/dist/cores/functions/test.js

@@ -1,7 +1,7 @@
 import { dirname } from 'node:path';
 import { testAction } from '../../actions/functions/test.js';
 import config from '../../config.js';
-import { STEP_PHASE_GLYPH } from '../../constants.js';
+import { SANITY_FUNCTION_DURABLE, STEP_PHASE_GLYPH } from '../../constants.js';
 import { resolveDeployedResources } from '../../utils/blueprints/resolve-deployed-resources.js';
 import { createDurableJsonCollector } from '../../utils/functions/durable-logs.js';
 import { findFunctionInResources, getFunctionNames } from '../../utils/functions/find.js';
@@ -55,7 +55,7 @@ export async function functionTestCore(options) {
             apiHost: config.apiUrl,
             token: config.token || undefined,
             withUserToken,
-            resources: resolvedResources,
+            resolvedResources,
             blueprintFileDir: dirname(blueprint.fileInfo.blueprintFilePath),
             log,
         };
@@ -88,15 +88,40 @@ export async function functionTestCore(options) {
          * surfaced after the spinner resolves, including failed ones — a downstream
          * error is fire-and-forget (it doesn't reject the caller) but is still shown.
          */
-        const runNested = async (nestedName, nestedPayload, ctx, depth, callStack) => {
+        const runNested = async (nestedName, nestedPayload, ctx, depth, callStack, metadata) => {
             const order = ++nestedOrder;
             const nestedResource = findFunctionInResources(blueprint.resources, nestedName);
-            const result = await runFunction(nestedResource, { payload: nestedPayload, event: 'nested' }, { ...ctx, resources: resolvedResources }, { depth, callStack, onNestedInvoke: runNested });
-            nestedRuns.push({ order, name: nestedName, logs: result.logs, error: result.error });
-            return result;
+            const isLiveDurable = metadata?.origin === 'step.delegate' && nestedResource.type === SANITY_FUNCTION_DURABLE;
+            if (isLiveDurable) {
+                log(`↳ BEGIN: invoke('${nestedName}')`);
+            }
+            try {
+                const result = await runFunction(nestedResource, { payload: nestedPayload, event: 'nested' }, { ...ctx, resources: resolvedResources }, { depth, callStack, onNestedInvoke: runNested, onStepEvent });
+                if (result.error && isLiveDurable) {
+                    log(result.error.stack || result.error.message);
+                }
+                nestedRuns.push({
+                    order,
+                    name: nestedName,
+                    logs: result.logs,
+                    error: result.error,
+                    isLiveDurable,
+                });
+                return result;
+            }
+            finally {
+                if (isLiveDurable) {
+                    log(`↳ END: invoke('${nestedName}')`);
+                }
+            }
         };
         const logNestedRuns = () => {
-            for (const run of [...nestedRuns].sort((a, b) => a.order - b.order)) {
+            // Remove buffered logs for durable runs
+            const runs = plan.isDurable ? nestedRuns.splice(0) : [...nestedRuns];
+            for (const run of runs.sort((a, b) => a.order - b.order)) {
+                // Skip if is Durable so log ordering is retained
+                if (run.isLiveDurable)
+                    continue;
                 log(`↳ BEGIN: invoke('${run.name}')`);
                 // Show any logs received
                 if (run.logs?.trim()) {
@@ -132,10 +157,19 @@ export async function functionTestCore(options) {
                 if (event.kind === 'delegate') {
                     logNestedRuns();
                 }
-                const glyph = STEP_PHASE_GLYPH[event.phase] ?? '•';
+                const willRetry = event.phase === 'error' && typeof event.retryDelayMs === 'number';
+                const glyph = willRetry ? '⟳' : (STEP_PHASE_GLYPH[event.phase] ?? '•');
                 const duration = typeof event.durationMs === 'number' ? ` (${Math.round(event.durationMs)}ms)` : '';
+                const retriesPerformed = (event.attempt ?? 1) - 1;
+                let retryNote = '';
+                if (willRetry) {
+                    retryNote = ` retry ${event.attempt} of ${event.maxAttempts}`;
+                }
+                else if (event.phase === 'error' && retriesPerformed > 0) {
+                    retryNote = ` failed after ${retriesPerformed} retries`;
+                }
                 const detail = event.phase === 'error' && event.error ? ` ${event.error.message}` : '';
-                lines.push(`  ${glyph} ${event.name} [${event.kind}]${duration}${detail}`);
+                lines.push(`  ${glyph} ${event.name} [${event.kind}]${duration}${detail}${retryNote}`);
             }
             return lines;
         }

package/dist/functions/artifacts.d.ts

@@ -0,0 +1,13 @@
+export declare const functionOutputFileName = "index.js";
+/** Metadata for a compiled function, resolved without loading its handler. */
+export interface FunctionBuild {
+    name: string;
+    src: string;
+    entryPoint: string;
+}
+/** Validate artifacts produced by buildFunction before packaging or deployment. */
+export declare function readFunctionBuild(options: {
+    name: string;
+    src: string;
+    workDir: string;
+}): Promise<FunctionBuild>;

package/dist/functions/artifacts.js

@@ -0,0 +1,26 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { findFunctionEntryPoint } from '../utils/functions/find-entry-point.js';
+export const functionOutputFileName = 'index.js';
+/** Validate artifacts produced by buildFunction before packaging or deployment. */
+export async function readFunctionBuild(options) {
+    const { name, workDir } = options;
+    const src = path.resolve(workDir, options.src);
+    try {
+        const pkg = JSON.parse(await readFile(path.join(src, 'package.json'), 'utf8'));
+        if (!pkg ||
+            typeof pkg !== 'object' ||
+            !('main' in pkg) ||
+            pkg.main !== functionOutputFileName ||
+            !('type' in pkg) ||
+            pkg.type !== 'module')
+            throw new Error('The function package metadata does not match its build format.');
+        const entryPoint = await findFunctionEntryPoint(src, name);
+        if (entryPoint !== path.join(src, functionOutputFileName))
+            throw new Error(`The compiled entry ${functionOutputFileName} is missing.`);
+        return { name, src, entryPoint };
+    }
+    catch (error) {
+        throw new Error(`Function "${name}" is not built. Run sanity build first.`, { cause: error });
+    }
+}

package/dist/functions/build.d.ts

@@ -0,0 +1,15 @@
+import { type FunctionContract } from './contracts.js';
+export interface BuildFunctionOptions {
+    name: string;
+    contract?: FunctionContract;
+    /** Function directory or entry file, relative to workDir. */
+    src: string;
+    workDir: string;
+    /** Build output directory, relative to workDir. Its contents are replaced. */
+    outDir: string;
+}
+/** Build a standalone ESM function bundle without a blueprint, stack, or ZIP. */
+export declare function buildFunction({ name, src, workDir, outDir, contract, }: BuildFunctionOptions): Promise<{
+    outputDir: string;
+}>;
+export { type FunctionBuild, readFunctionBuild } from './artifacts.js';

package/dist/functions/build.js

@@ -0,0 +1,27 @@
+import path from 'node:path';
+import { findFunctionEntryPoint } from '../utils/functions/find-entry-point.js';
+import { transpileFunction } from '../utils/functions/transpile/function.js';
+import { functionOutputFileName } from './artifacts.js';
+import { functionContractPlugin } from './contractPlugin.js';
+import { generateFunctionContracts } from './contracts.js';
+/** Build a standalone ESM function bundle without a blueprint, stack, or ZIP. */
+export async function buildFunction({ name, src, workDir, outDir, contract, }) {
+    const functionPath = path.resolve(workDir, src);
+    const entryPoint = await findFunctionEntryPoint(functionPath, name);
+    const resolvedContract = contract ?? (await generateFunctionContracts({ workDir, functions: [{ name, src }] }))[0];
+    if (resolvedContract.entryPoint !== entryPoint || resolvedContract.name !== name)
+        throw new Error(`Function contract does not match "${name}".`);
+    const validation = functionContractPlugin(resolvedContract);
+    const result = await transpileFunction({
+        resource: { name, src, type: 'sanity.function.pubsub' },
+        functionPath,
+        entryPoint: validation.entryPoint,
+        plugins: [validation.plugin],
+        workDir,
+        outDir: path.resolve(workDir, outDir),
+        outputFileName: functionOutputFileName,
+        bundle: true,
+    });
+    return { outputDir: result.outputDir };
+}
+export { readFunctionBuild } from './artifacts.js';

package/dist/functions/contractPlugin.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from 'vite';
+import type { FunctionContract } from './contracts.js';
+/** Build a validating PubSub entry around the original handler. */
+export declare function functionContractPlugin(contract: FunctionContract): {
+    entryPoint: string;
+    plugin: Plugin;
+};

package/dist/functions/contractPlugin.js

@@ -0,0 +1,32 @@
+import { jsonGuard, validatorSource } from './contracts/validation.js';
+/** Build a validating PubSub entry around the original handler. */
+export function functionContractPlugin(contract) {
+    const entryPoint = `virtual:sanity-function-contract:${contract.name}`;
+    const resolvedId = `\0${entryPoint}`;
+    const source = `import {handler as implementation} from ${JSON.stringify(contract.entryPoint.replaceAll('\\', '/'))}
+${jsonGuard}
+const validateInput = ${validatorSource(contract.input)}
+const validateOutput = ${validatorSource(contract.output)}
+export async function handler(envelope) {
+  let input = envelope?.event?.data
+  ${contract.input.kind === 'void' ? "if (input !== null && typeof input === 'object' && !Array.isArray(input) && Object.keys(input).length === 0) input = undefined" : ''}
+  if (!validateInput(input)) throw new TypeError(${JSON.stringify(`Invalid input for function "${contract.name}". Match its declared input type.`)})
+  const result = await implementation(envelope)
+  if (!validateOutput(result)) throw new TypeError(${JSON.stringify(`Function "${contract.name}" returned data that does not match its declared return type.`)})
+  return result
+}`;
+    return {
+        entryPoint,
+        plugin: {
+            name: 'sanity/function-contract',
+            resolveId(id) {
+                if (id === entryPoint)
+                    return resolvedId;
+            },
+            load(id) {
+                if (id === resolvedId)
+                    return source;
+            },
+        },
+    };
+}

package/dist/functions/contracts/schema.d.ts

@@ -0,0 +1,22 @@
+import ts from 'typescript-compiler';
+export type ContractSchema = {
+    kind: 'string' | 'number' | 'boolean' | 'null' | 'void' | 'never';
+} | {
+    kind: 'literal';
+    value: string | number | boolean;
+} | {
+    kind: 'array';
+    items: ContractSchema;
+} | {
+    kind: 'union';
+    variants: ContractSchema[];
+} | {
+    kind: 'object';
+    properties: Record<string, {
+        optional: boolean;
+        schema: ContractSchema;
+    }>;
+    additional?: ContractSchema;
+};
+export declare function schemaFromType(checker: ts.TypeChecker, type: ts.Type, location: string, allowVoid?: boolean, parents?: Set<ts.Type>): ContractSchema;
+export declare function contractType(schema: ContractSchema): string;

package/dist/functions/contracts/schema.js

@@ -0,0 +1,99 @@
+import ts from 'typescript-compiler';
+export function schemaFromType(checker, type, location, allowVoid = false, parents = new Set()) {
+    const fail = (reason) => {
+        throw new Error(`${location}: ${reason} (${checker.typeToString(type)}). Use a concrete JSON-compatible type.`);
+    };
+    const flags = type.flags;
+    if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.TypeParameter))
+        return fail('Unresolved or untyped contract');
+    if (flags & ts.TypeFlags.Never)
+        return { kind: 'never' };
+    if (flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined)) {
+        if (!allowVoid)
+            return fail('Undefined is only supported for optional object fields or a void result');
+        return { kind: 'void' };
+    }
+    if (flags & ts.TypeFlags.Null)
+        return { kind: 'null' };
+    if (flags & ts.TypeFlags.StringLiteral)
+        return { kind: 'literal', value: type.value };
+    if (flags & ts.TypeFlags.NumberLiteral)
+        return { kind: 'literal', value: type.value };
+    if (flags & ts.TypeFlags.BooleanLiteral)
+        return { kind: 'literal', value: checker.typeToString(type) === 'true' };
+    if (flags & ts.TypeFlags.String)
+        return { kind: 'string' };
+    if (flags & ts.TypeFlags.Number)
+        return { kind: 'number' };
+    if (flags & ts.TypeFlags.Boolean)
+        return { kind: 'boolean' };
+    if (parents.has(type) || parents.size > 64)
+        return fail('Recursive or excessively nested contract');
+    const next = new Set(parents).add(type);
+    if (type.isUnion())
+        return {
+            kind: 'union',
+            variants: type.types.map((item) => schemaFromType(checker, item, location, allowVoid, next)),
+        };
+    if (checker.isTupleType(type))
+        return fail('Tuple contracts are not supported; use an array');
+    if (checker.isArrayType(type)) {
+        const element = checker.getTypeArguments(type)[0];
+        return { kind: 'array', items: schemaFromType(checker, element, `${location}[]`, false, next) };
+    }
+    if (!(flags & (ts.TypeFlags.Object | ts.TypeFlags.Intersection)))
+        return fail('Unsupported contract');
+    if (type.getCallSignatures().length || type.getConstructSignatures().length)
+        return fail('Functions and constructors cannot cross the function boundary');
+    if (type
+        .getSymbol()
+        ?.getDeclarations()
+        ?.some((declaration) => ts.isClassDeclaration(declaration) || ts.isClassExpression(declaration)))
+        return fail('Class instances cannot cross the function boundary');
+    if (checker.getIndexTypeOfType(type, ts.IndexKind.Number))
+        return fail('Numeric index signatures are not supported; use an array or string-keyed record');
+    const properties = Object.create(null);
+    for (const property of checker.getPropertiesOfType(type)) {
+        const name = property.getName();
+        if (name.startsWith('__@'))
+            return fail('Symbol properties cannot cross the function boundary');
+        const declaration = property.valueDeclaration ?? property.declarations?.[0];
+        if (!declaration)
+            return fail(`Cannot resolve property ${name}`);
+        const propertyType = checker.getTypeOfSymbolAtLocation(property, declaration);
+        const optional = !!(property.flags & ts.SymbolFlags.Optional);
+        const members = optional
+            ? (propertyType.isUnion() ? propertyType.types : [propertyType]).filter((member) => !(member.flags & ts.TypeFlags.Undefined))
+            : [propertyType];
+        const schemas = members.map((member) => schemaFromType(checker, member, `${location}.${name}`, false, next));
+        properties[name] = {
+            optional,
+            schema: schemas.length === 0
+                ? { kind: 'never' }
+                : schemas.length === 1
+                    ? schemas[0]
+                    : { kind: 'union', variants: schemas },
+        };
+    }
+    const indexType = checker.getIndexTypeOfType(type, ts.IndexKind.String);
+    const additional = indexType
+        ? schemaFromType(checker, indexType, `${location}[key]`, false, next)
+        : undefined;
+    return { kind: 'object', properties, ...(additional ? { additional } : {}) };
+}
+export function contractType(schema) {
+    switch (schema.kind) {
+        case 'literal':
+            return JSON.stringify(schema.value);
+        case 'array':
+            return `(${contractType(schema.items)})[]`;
+        case 'union':
+            return schema.variants.map(contractType).join(' | ');
+        case 'object':
+            return `{${Object.entries(schema.properties)
+                .map(([name, property]) => `${JSON.stringify(name)}${property.optional ? '?' : ''}: ${contractType(property.schema)};`)
+                .join(' ')}${schema.additional ? `[key: string]: ${contractType(schema.additional)};` : ''}}`;
+        default:
+            return schema.kind;
+    }
+}

package/dist/functions/contracts/validation.d.ts

@@ -0,0 +1,3 @@
+import type { ContractSchema } from './schema.js';
+export declare const jsonGuard = "function isJson(value, seen = new WeakSet(), depth = 0) {\n  if (depth > 100) return false\n  if (value === undefined || value === null) return true\n  if (typeof value === 'string' || typeof value === 'boolean') return true\n  if (typeof value === 'number') return Number.isFinite(value)\n  if (typeof value !== 'object' || seen.has(value) || Object.getOwnPropertySymbols(value).length) return false\n  seen.add(value)\n  try {\n    if (Array.isArray(value)) {\n      if (Object.keys(value).length !== value.length) return false\n      for (let index = 0; index < value.length; index++) {\n        if (!Object.hasOwn(value, index) || value[index] === undefined || !isJson(value[index], seen, depth + 1)) return false\n      }\n      return true\n    }\n    const prototype = Object.getPrototypeOf(value)\n    return (prototype === Object.prototype || prototype === null) && Object.values(value).every(item => isJson(item, seen, depth + 1))\n  } finally { seen.delete(value) }\n}";
+export declare function validatorSource(schema: ContractSchema): string;

package/dist/functions/contracts/validation.js

@@ -0,0 +1,66 @@
+// Self-contained code emitted into browser contracts and function bundles.
+export const jsonGuard = `function isJson(value, seen = new WeakSet(), depth = 0) {
+  if (depth > 100) return false
+  if (value === undefined || value === null) return true
+  if (typeof value === 'string' || typeof value === 'boolean') return true
+  if (typeof value === 'number') return Number.isFinite(value)
+  if (typeof value !== 'object' || seen.has(value) || Object.getOwnPropertySymbols(value).length) return false
+  seen.add(value)
+  try {
+    if (Array.isArray(value)) {
+      if (Object.keys(value).length !== value.length) return false
+      for (let index = 0; index < value.length; index++) {
+        if (!Object.hasOwn(value, index) || value[index] === undefined || !isJson(value[index], seen, depth + 1)) return false
+      }
+      return true
+    }
+    const prototype = Object.getPrototypeOf(value)
+    return (prototype === Object.prototype || prototype === null) && Object.values(value).every(item => isJson(item, seen, depth + 1))
+  } finally { seen.delete(value) }
+}`;
+export function validatorSource(schema) {
+    return `(value) => isJson(value) && (${validationExpression(schema, 'value')})`;
+}
+function validationExpression(schema, value, depth = 0) {
+    switch (schema.kind) {
+        case 'void':
+            return `${value} === undefined`;
+        case 'never':
+            return 'false';
+        case 'null':
+            return `${value} === null`;
+        case 'literal':
+            return `${value} === ${JSON.stringify(schema.value)}`;
+        case 'number':
+            return `(typeof ${value} === 'number' && Number.isFinite(${value}))`;
+        case 'string':
+        case 'boolean':
+            return `typeof ${value} === '${schema.kind}'`;
+        case 'union':
+            return `(${schema.variants.map((item) => `(${validationExpression(item, value, depth + 1)})`).join(' || ')})`;
+        case 'array': {
+            const item = `item${depth}`;
+            return `(Array.isArray(${value}) && ${value}.every(${item} => ${validationExpression(schema.items, item, depth + 1)}))`;
+        }
+        case 'object': {
+            const checks = [
+                `${value} !== null`,
+                `typeof ${value} === 'object'`,
+                `!Array.isArray(${value})`,
+            ];
+            for (const [name, property] of Object.entries(schema.properties)) {
+                const member = `${value}[${JSON.stringify(name)}]`;
+                const present = `Object.hasOwn(${value}, ${JSON.stringify(name)})`;
+                const check = validationExpression(property.schema, member, depth + 1);
+                checks.push(property.optional
+                    ? `(!${present} || ${member} === undefined || (${check}))`
+                    : `(${present} && (${check}))`);
+            }
+            if (schema.additional) {
+                const key = `key${depth}`;
+                checks.push(`Object.keys(${value}).every(${key} => ${JSON.stringify(Object.keys(schema.properties))}.includes(${key}) || (${validationExpression(schema.additional, `${value}[${key}]`, depth + 1)}))`);
+            }
+            return `(${checks.join(' && ')})`;
+        }
+    }
+}

package/dist/functions/contracts.d.ts

@@ -0,0 +1,20 @@
+import { type ContractSchema } from './contracts/schema.js';
+export interface FunctionContract {
+    name: string;
+    src: string;
+    entryPoint: string;
+    input: ContractSchema;
+    output: ContractSchema;
+}
+/** Discover input and output types without loading or executing function code. */
+export declare function generateFunctionContracts(options: {
+    workDir: string;
+    functions: {
+        name: string;
+        src: string;
+    }[];
+}): Promise<FunctionContract[]>;
+/** Check app consumers after regenerating their function registry. */
+export declare function checkFunctionTypes(workDir: string): void;
+/** Emit a standalone declaration registry and browser-safe validators. */
+export declare function writeFunctionContracts(workDir: string, contracts: FunctionContract[]): Promise<void>;