@superpanel-sdk/runtime 0.5.0 → 0.7.0

package/dist/builder/compile/registry.d.ts

@@ -1,19 +1,19 @@
 import { type AnyEventHandlers } from '../../core/functions/events.js';
 import type { FuncMap, FunctionRegistry } from '../../core/functions/types.js';
+import type { FunctionSourceMap } from '../types.js';
 export type BuildRegistryOptions = {
     /** When false, skip esbuild and omit `code` (local serve overlay). Default true. */
     includeCode?: boolean;
     /** Source module used to bundle module-local helpers and constants. */
     modulePath?: string;
+    /** Receives each function's source map by name (a module's bundle only): kept out of the registry. */
+    sourceMaps?: Record<string, FunctionSourceMap>;
 };
 /**
  * Project author FuncMap → JSON-safe registry.
  * Published builds include per-function compiled `code`; overlay omits it.
  */
 export declare function toFunctionRegistry(functions: FuncMap, options?: BuildRegistryOptions): Promise<FunctionRegistry>;
-/**
- * Project the company `events` export → JSON-safe registry. The kind of each
- * handler is fixed by the platform event table (`case` / `noCase`), not by the author.
- */
+/** Project the company `events` export → JSON-safe registry: each handler by its event's name. */
 export declare function toEventRegistry(events: AnyEventHandlers, options?: BuildRegistryOptions): Promise<FunctionRegistry>;
 //# sourceMappingURL=registry.d.ts.map

package/dist/builder/compile/registry.js

@@ -1,5 +1,11 @@
-import { isSystemEventName, systemEventKind } from '../../core/functions/events.js';
+import { isSystemEventName } from '../../core/functions/events.js';
 import { compileEventModuleCode, compileFunctionCode, compileFunctionModuleCode } from './function-code.js';
+/** The bundle's code; its map goes to `sourceMaps`. */
+function keepMap(name, compiled, sourceMaps) {
+    if (sourceMaps)
+        sourceMaps[name] = compiled.map;
+    return compiled.code;
+}
 function withCode(entry, code) {
     if (code === undefined)
         return entry;
@@ -12,21 +18,17 @@ function withCode(entry, code) {
 export async function toFunctionRegistry(functions, options = {}) {
     const includeCode = options.includeCode ?? true;
     const out = {};
-    for (const [name, def] of Object.entries(functions)) {
+    for (const [name, fn] of Object.entries(functions)) {
         const code = includeCode
             ? options.modulePath
-                ? await compileFunctionModuleCode(options.modulePath, name)
-                : await compileFunctionCode(def.main)
+                ? keepMap(name, await compileFunctionModuleCode(options.modulePath, name), options.sourceMaps)
+                : await compileFunctionCode(fn)
             : undefined;
-        const entry = withCode({ kind: def.kind }, code);
-        out[name] = entry;
+        out[name] = withCode({}, code);
     }
     return out;
 }
-/**
- * Project the company `events` export → JSON-safe registry. The kind of each
- * handler is fixed by the platform event table (`case` / `noCase`), not by the author.
- */
+/** Project the company `events` export → JSON-safe registry: each handler by its event's name. */
 export async function toEventRegistry(events, options = {}) {
     const includeCode = options.includeCode ?? true;
     const out = {};
@@ -39,10 +41,10 @@ export async function toEventRegistry(events, options = {}) {
         }
         const code = includeCode
             ? options.modulePath
-                ? await compileEventModuleCode(options.modulePath, name)
+                ? keepMap(name, await compileEventModuleCode(options.modulePath, name), options.sourceMaps)
                 : await compileFunctionCode(handler)
             : undefined;
-        out[name] = withCode({ kind: systemEventKind(name) }, code);
+        out[name] = withCode({}, code);
     }
     return out;
 }

package/dist/builder/errors.d.ts

@@ -0,0 +1,9 @@
+import type { FuncMap } from '../core/functions/types.js';
+/** The repository root's `errors.ts`, loaded: its `onError`, what serve runs. `null` without the file. */
+export type LoadedOnError = {
+    path: string;
+    functions: FuncMap;
+};
+/** Load and check the repository root's `errors.ts` (67 §5): it exports `onError`, a function. */
+export declare function loadOnError(repoRoot: string): Promise<LoadedOnError | null>;
+//# sourceMappingURL=errors.d.ts.map

package/dist/builder/errors.js

@@ -0,0 +1,17 @@
+import { pathToFileURL } from 'node:url';
+import { ERRORS_MODULE, ON_ERROR_FUNCTION } from '../core/functions/errors.js';
+import { companyImportGraphHref } from './company-import-graph.js';
+import { findTsModule } from './paths.js';
+/** Load and check the repository root's `errors.ts` (67 §5): it exports `onError`, a function. */
+export async function loadOnError(repoRoot) {
+    const modulePath = findTsModule(repoRoot, ERRORS_MODULE);
+    if (!modulePath)
+        return null;
+    const mod = (await import(companyImportGraphHref(pathToFileURL(modulePath).href)));
+    const onError = mod[ON_ERROR_FUNCTION] ?? mod.default;
+    if (typeof onError !== 'function') {
+        throw new Error(`${ERRORS_MODULE}.ts: export const ${ON_ERROR_FUNCTION}: OnError = async (ctx, { error }) => { … } (67 §5)`);
+    }
+    return { path: modulePath, functions: { [ON_ERROR_FUNCTION]: onError } };
+}
+//# sourceMappingURL=errors.js.map

package/dist/builder/function-params.d.ts

@@ -0,0 +1,10 @@
+import type { ActionParameters } from '../core/page/define.js';
+export declare class FunctionParamsError extends Error {
+}
+/**
+ * The parameters of every function in `exportName` of `modulePath`, by its key. A function with no
+ * second parameter takes none (`{ type: 'object', properties: {} }`). A `define*` result (no call
+ * signature) is left out: it declares its own.
+ */
+export declare function readFunctionParameters(modulePath: string, exportName: string): Record<string, ActionParameters>;
+//# sourceMappingURL=function-params.d.ts.map

package/dist/builder/function-params.js

@@ -0,0 +1,203 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { API, SignatureKind, SymbolFlags, TypeFlags, } from 'typescript/unstable/sync';
+/**
+ * A function's parameters from its TypeScript type (38 §2.4): the builder reads the second parameter of
+ * each function in a registry export (`functions`, `actions` of `actions.ts`) as the pinned TypeScript's checker
+ * sees it, expanded, and writes what the AI sees of it. Whatever falls outside the types below is the
+ * author's mistake, said with the type to use instead.
+ */
+/** The marks `Id<T>` and the format types carry (`core/page/typed.ts`), as the checker names them. */
+const ID_MARK = /^__@ID_BRAND@/;
+const FORMAT_MARK = /^__@FORMAT_BRAND@/;
+const FORMATS = new Set(['date', 'datetime', 'time', 'phone', 'email']);
+const PARAMETER_TYPES = "string, number, boolean, literals ('a' | 'b'), Id<'table'>, IsoDate, IsoDateTime, TimeOfDay, Phone, Email, ContactSchedule, a list or an object";
+export class FunctionParamsError extends Error {
+}
+/** The repository's `tsconfig.json`: the nearest one above the module. */
+function tsconfigOf(modulePath) {
+    for (let dir = path.dirname(modulePath);; dir = path.dirname(dir)) {
+        const candidate = path.join(dir, 'tsconfig.json');
+        if (existsSync(candidate))
+            return candidate;
+        if (path.dirname(dir) === dir)
+            throw new FunctionParamsError(`${modulePath}: no tsconfig.json above it`);
+    }
+}
+/**
+ * The parameters of every function in `exportName` of `modulePath`, by its key. A function with no
+ * second parameter takes none (`{ type: 'object', properties: {} }`). A `define*` result (no call
+ * signature) is left out: it declares its own.
+ */
+export function readFunctionParameters(modulePath, exportName) {
+    const tsconfig = tsconfigOf(modulePath);
+    const api = new API({ cwd: path.dirname(tsconfig) });
+    try {
+        const snapshot = api.updateSnapshot({ openProjects: [tsconfig] });
+        const project = snapshot.getDefaultProjectForFile(modulePath) ?? snapshot.getProject(tsconfig);
+        const source = project?.program.getSourceFile(modulePath);
+        if (!project || !source)
+            throw new FunctionParamsError(`${modulePath}: not part of ${tsconfig}'s program`);
+        const { checker } = project;
+        const moduleSymbol = checker.getSymbolAtLocation(source);
+        const exported = moduleSymbol
+            ? checker.getExportsOfModule(moduleSymbol).find((s) => s.name === exportName)
+            : undefined;
+        if (!exported)
+            return {};
+        const registry = checker.getTypeOfSymbol(exported);
+        if (!registry)
+            return {};
+        const where = path.basename(modulePath);
+        const out = {};
+        for (const entry of checker.getPropertiesOfType(registry)) {
+            // JavaScript keeps this name for an object's prototype: as a key it is easily not the object's own.
+            if (entry.name === '__proto__')
+                throw new FunctionParamsError(`${path.basename(modulePath)}: ${exportName}.__proto__: pick another name`);
+            const type = checker.getTypeOfSymbol(entry);
+            if (!type)
+                continue;
+            const signatures = checker.getSignaturesOfType(type, SignatureKind.Call);
+            if (signatures.length === 0)
+                continue;
+            const label = `${where}: ${exportName}.${entry.name}`;
+            if (signatures.length > 1)
+                throw new FunctionParamsError(`${label} is overloaded: a function has one signature, (ctx, args)`);
+            const signature = signatures[0];
+            // `(...args)` hides how many it takes and which is args: the builder could not show the AI what to fill.
+            if (signature.hasRestParameter)
+                throw new FunctionParamsError(`${label} takes a rest parameter: a function takes (ctx, args), args one object`);
+            const params = signature.getParameters();
+            if (params.length > 2)
+                throw new FunctionParamsError(`${label} takes ${params.length} parameters: a function takes (ctx, args), args one object`);
+            if (params.length < 2) {
+                out[entry.name] = { type: 'object', properties: {} };
+                continue;
+            }
+            const argsType = checker.getParameterType(signature, 1);
+            if (!argsType)
+                throw new FunctionParamsError(`${label}: the type checker cannot read its args`);
+            const optional = params[1].flags & SymbolFlags.Optional ||
+                (argsType.isUnionType() && argsType.getTypes().some((t) => t.flags & TypeFlags.Undefined));
+            if (optional)
+                throw new FunctionParamsError(`${label}: args must be one object parameter, not optional`);
+            const top = objectParam(checker, argsType, `${label}(args)`);
+            out[entry.name] = {
+                type: 'object',
+                properties: top.properties,
+                ...(top.required?.length ? { required: top.required } : {}),
+            };
+        }
+        return out;
+    }
+    finally {
+        api.close();
+    }
+}
+/** A union's members without `undefined` (an optional parameter's); any other type alone. */
+function withoutUndefined(type) {
+    return (type.isUnionType() ? type.getTypes() : [type]).filter((t) => !(t.flags & TypeFlags.Undefined));
+}
+function isPlainObject(checker, type) {
+    return (type.isObjectType() &&
+        !checker.isArrayType(type) &&
+        checker.getSignaturesOfType(type, SignatureKind.Call).length === 0);
+}
+function objectParam(checker, type, where) {
+    if (!isPlainObject(checker, type) &&
+        !(type.isIntersectionType() && type.getTypes().every((t) => isPlainObject(checker, t)))) {
+        throw new FunctionParamsError(`${where}: not an object of named parameters`);
+    }
+    if (checker.getIndexInfosOfType(type).length > 0)
+        throw new FunctionParamsError(`${where} has an index signature (Record<string, …>): name each parameter`);
+    const properties = {};
+    const required = [];
+    for (const prop of checker.getPropertiesOfType(type)) {
+        const propType = checker.getTypeOfSymbol(prop);
+        if (!propType)
+            throw new FunctionParamsError(`${where}.${prop.name}: the type checker cannot read it`);
+        // A row inside an object or a list is the page's to prefill: the page refuses it where the AI would choose (35 §2).
+        const optional = (prop.flags & SymbolFlags.Optional) !== 0;
+        // One way to say optional, the one the AI reads (76 §2.14): `name?: T`. `name: T | undefined` is
+        // optional to the type checker and required here; the page's `doNow()` check and the AI would disagree.
+        if (!optional && (propType.isUnionType() ? propType.getTypes() : [propType]).some((t) => t.flags & TypeFlags.Undefined)) {
+            throw new FunctionParamsError(`${where}.${prop.name}: T | undefined: write an optional parameter as ${prop.name}?: T`);
+        }
+        properties[prop.name] = valueParam(checker, propType, `${where}.${prop.name}`);
+        if (!optional)
+            required.push(prop.name);
+    }
+    return { type: 'object', properties, ...(required.length ? { required } : {}) };
+}
+function valueParam(checker, type, where) {
+    const members = withoutUndefined(type);
+    if (members.some((t) => t.flags & TypeFlags.Null))
+        throw new FunctionParamsError(`${where}: null is not a value the AI fills: make the parameter optional (name?: T)`);
+    if (members.length === 0)
+        throw new FunctionParamsError(`${where}: no type`);
+    // A union of literals: what the AI may choose among; `boolean` is `true | false`.
+    if (members.length > 1 || members[0].isLiteralType()) {
+        if (members.every((t) => t.flags & TypeFlags.BooleanLiteral))
+            return { type: 'boolean' };
+        if (members.every((t) => t.isStringLiteralType()))
+            return { type: 'string', enum: members.map((t) => t.value) };
+        if (members.every((t) => t.isNumberLiteralType()))
+            return { type: 'number', enum: members.map((t) => t.value) };
+        if (members.length > 1)
+            throw new FunctionParamsError(`${where} mixes types: use one of ${PARAMETER_TYPES}`);
+    }
+    const only = members[0];
+    // A contact's hours (25 §3): the runtime's `ContactSchedule`, checked as the field's value is.
+    if (only.getAliasSymbol()?.name === 'ContactSchedule')
+        return { type: 'contact_schedule' };
+    if (only.flags & (TypeFlags.Any | TypeFlags.Unknown))
+        throw new FunctionParamsError(`${where}: any / unknown says nothing: use one of ${PARAMETER_TYPES}`);
+    if (only.flags & TypeFlags.String)
+        return { type: 'string' };
+    if (only.flags & TypeFlags.Number)
+        return { type: 'number' };
+    if (only.flags & TypeFlags.Boolean)
+        return { type: 'boolean' };
+    if (only.isIntersectionType()) {
+        const marked = markOf(checker, only);
+        if (marked)
+            return marked;
+        if (only.getTypes().every((t) => isPlainObject(checker, t)))
+            return objectParam(checker, only, where);
+        throw new FunctionParamsError(`${where} is not a parameter type: use one of ${PARAMETER_TYPES}`);
+    }
+    if (checker.isArrayType(only)) {
+        const item = only.isTypeReference() ? checker.getTypeArguments(only)[0] : undefined;
+        if (!item)
+            throw new FunctionParamsError(`${where}: a list of what?`);
+        return { type: 'array', items: valueParam(checker, item, `${where}[]`) };
+    }
+    if (only.isObjectType()) {
+        if (checker.getSignaturesOfType(only, SignatureKind.Call).length > 0)
+            throw new FunctionParamsError(`${where}: a function is not a value the AI fills`);
+        return objectParam(checker, only, where);
+    }
+    throw new FunctionParamsError(`${where} is not a parameter type: use one of ${PARAMETER_TYPES}`);
+}
+/** `Id<'table'>` → a row of `table`; a format type → its format. Null when the intersection carries neither mark. */
+function markOf(checker, type) {
+    if (!type.getTypes().some((t) => t.flags & TypeFlags.String))
+        return null;
+    for (const prop of checker.getPropertiesOfType(type)) {
+        const name = String(prop.escapedName);
+        const isId = ID_MARK.test(name);
+        if (!isId && !FORMAT_MARK.test(name))
+            continue;
+        const value = literalOf(checker, prop);
+        if (isId)
+            return value ? { type: 'ref', table: value } : null;
+        return value && FORMATS.has(value) ? { type: value } : null;
+    }
+    return null;
+}
+function literalOf(checker, prop) {
+    const type = checker.getTypeOfSymbol(prop);
+    const literal = type ? withoutUndefined(type).find((t) => t.isStringLiteralType()) : undefined;
+    return literal ? literal.value : null;
+}
+//# sourceMappingURL=function-params.js.map

package/dist/builder/load.d.ts

@@ -1,6 +1,6 @@
-import type { CompanyResolveInput, CompanyResolveResult, ResolveInput, ResolveResult } from '../core/party/schema.js';
-import { type AnyEventHandlers, type WebhookEvent, type WebhookOutcome } from '../core/functions/events.js';
-import type { DefinedNoCaseFunc, FuncMap } from '../core/functions/types.js';
+import { type CompanyResolve, type Resolve } from '../core/party/types.js';
+import { type AnyEventHandlers, type WebhookHandler } from '../core/functions/events.js';
+import type { FuncMap, PlainFn } from '../core/functions/types.js';
 import { type OfficeHours } from '../core/office-hours/index.js';
 import { type CompanySchema, type SessionSchema } from '../core/slot/schema.js';
 /**
@@ -40,23 +40,23 @@ export declare function loadSequenceEvents(eventsPath: string): Promise<AnyEvent
  */
 export declare function loadPageChannels(pageCode: string, sequenceId: string): string[];
 /**
- * The Case Orchestrator from orchestrator.ts / orchestrator/index.ts: the entry point (`orchestrator`, or
- * the default export) and `contacts`, whom a Run may contact (required: the platform runs it first).
+ * What the compiled page code says of itself as it loads: its channels, and the page actions it
+ * registered (76 §2.11), read in a context of its own as `loadPageChannels` does.
  */
-export declare function loadSequenceCaseOrchestrator(caseOrchestratorPath: string): Promise<{
-    orchestrator: (...args: never[]) => unknown;
-    contacts: (...args: never[]) => unknown;
-}>;
-/** A sequence's `resolve`, registered as a `noCase` function. */
-export declare function loadSequenceResolver(resolvePath: string): Promise<DefinedNoCaseFunc<ResolveInput, ResolveResult>>;
-/** The company `resolve` (§18.2), registered as a `noCase` function of the company part (22 §5). */
-export declare function loadCompanyResolver(resolvePath: string): Promise<DefinedNoCaseFunc<CompanyResolveInput, CompanyResolveResult>>;
+export declare function loadPageModule(pageCode: string, sequenceId: string): {
+    channels: string[];
+    actions: string[];
+};
+/** The Case Orchestrator from orchestrator.ts / orchestrator/index.ts: `orchestrator`, or the default export. */
+export declare function loadSequenceCaseOrchestrator(caseOrchestratorPath: string): Promise<PlainFn>;
+/** A sequence's `resolve`: `(ctx, conversation)`. */
+export declare function loadSequenceResolver(resolvePath: string): Promise<Resolve>;
+/** The company `resolve` (§18.2), a function of the company part (22 §5): `(ctx, conversation)`. */
+export declare function loadCompanyResolver(resolvePath: string): Promise<CompanyResolve>;
 /** The module of the company's webhooks (22 §9) at the repository root. */
 export declare const WEBHOOK_MODULE = "webhook";
-/** `received` of `webhook.ts`, registered as a `noCase` function of the company part. */
-export declare function loadCompanyWebhook(webhookPath: string): Promise<DefinedNoCaseFunc<{
-    event: WebhookEvent;
-}, WebhookOutcome>>;
+/** `received` of `webhook.ts`, a function of the company part: `(ctx, { event })`. */
+export declare function loadCompanyWebhook(webhookPath: string): Promise<WebhookHandler>;
 export declare function isPlatformName(name: string): boolean;
 /**
  * A leftover root `channels.ts` (or `channels/index.ts`): webhook URLs are made and named on the

package/dist/builder/load.js

@@ -19,18 +19,14 @@ function isFuncMap(value) {
     if (value == null || typeof value !== 'object' || Array.isArray(value)) {
         return false;
     }
-    for (const entry of Object.values(value)) {
-        if (entry == null || typeof entry !== 'object' || Array.isArray(entry)) {
-            return false;
-        }
-        const kind = entry.kind;
-        if (kind === 'compute' || kind === 'boolCompute') {
-            // Compute functions only existed as derived fields' computeFn (13-data-model-v1 §21).
-            throw new Error(`functions: ${kind} functions were removed with derived fields; compute it in context.page.ts instead`);
-        }
-        if (kind !== 'case' && kind !== 'noCase') {
-            return false;
+    for (const [name, entry] of Object.entries(value)) {
+        if (typeof entry === 'function')
+            continue;
+        // A `defineCaseFunc(…)` / `defineNoCaseFunc(…)` result: functions are plain `(ctx, args)` now (38 §2.1).
+        if (entry != null && typeof entry === 'object' && 'main' in entry) {
+            throw new Error(`functions.${name}: write it as a plain function (ctx, args), its parameters its args type (docs 38; AGENTS.md, "Functions")`);
         }
+        return false;
     }
     return true;
 }
@@ -262,29 +258,35 @@ export async function loadSequenceEvents(eventsPath) {
  * called when a conversation starts (24 §4), not here.
  */
 export function loadPageChannels(pageCode, sequenceId) {
+    return loadPageModule(pageCode, sequenceId).channels;
+}
+/**
+ * What the compiled page code says of itself as it loads: its channels, and the page actions it
+ * registered (76 §2.11), read in a context of its own as `loadPageChannels` does.
+ */
+export function loadPageModule(pageCode, sequenceId) {
     try {
         const entry = runInNewContext(pageCode);
+        const out = entry({ mode: 'channels' });
         // Copied out of the other context: its arrays are not this one's.
-        return [...(entry({ mode: 'channels' }).channels ?? [])].map(String);
+        return { channels: [...(out.channels ?? [])].map(String), actions: [...(out.actions ?? [])].map(String) };
     }
     catch (error) {
         throw new Error(`sequences/${sequenceId}/context.page.ts: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-/**
- * The Case Orchestrator from orchestrator.ts / orchestrator/index.ts: the entry point (`orchestrator`, or
- * the default export) and `contacts`, whom a Run may contact (required: the platform runs it first).
- */
+/** The Case Orchestrator from orchestrator.ts / orchestrator/index.ts: `orchestrator`, or the default export. */
 export async function loadSequenceCaseOrchestrator(caseOrchestratorPath) {
     const mod = await importModule(caseOrchestratorPath);
     const orchestrator = [mod[ORCHESTRATOR_FUNCTION], mod.default].find((value) => typeof value === 'function');
     if (!orchestrator) {
         throw new Error(`Could not find ${ORCHESTRATOR_FUNCTION} export (${ORCHESTRATOR_FUNCTION} | default) as a function in ${caseOrchestratorPath}`);
     }
-    if (typeof mod.contacts !== 'function') {
-        throw new Error(`${caseOrchestratorPath}: export contacts, whom a Run may contact: export const contacts: CaseOrchestratorContacts = async (c, ctx) => contactIds`);
+    // Whom a Run may contact is the Orchestrator's to read now (38 §2.8).
+    if (Object.hasOwn(mod, 'contacts')) {
+        throw new Error(`${caseOrchestratorPath}: contacts is no longer supported: delete it. The orchestrator reads whom to contact from the business data, and names them on an Agent request (contacts: [...])`);
     }
-    return { orchestrator: orchestrator, contacts: mod.contacts };
+    return orchestrator;
 }
 /** A `resolve.ts` / `resolve/index.ts`: its exported function `resolve` (or the default export). */
 async function loadResolveExport(resolvePath) {
@@ -294,23 +296,23 @@ async function loadResolveExport(resolvePath) {
         return entry;
     throw new Error(`Could not find ${RESOLVE_FUNCTION} export (${RESOLVE_FUNCTION} | default) as a function in ${resolvePath}`);
 }
-/** A sequence's `resolve`, registered as a `noCase` function. */
+/** A sequence's `resolve`: `(ctx, conversation)`. */
 export async function loadSequenceResolver(resolvePath) {
-    return { kind: 'noCase', main: (await loadResolveExport(resolvePath)) };
+    return (await loadResolveExport(resolvePath));
 }
-/** The company `resolve` (§18.2), registered as a `noCase` function of the company part (22 §5). */
+/** The company `resolve` (§18.2), a function of the company part (22 §5): `(ctx, conversation)`. */
 export async function loadCompanyResolver(resolvePath) {
-    return { kind: 'noCase', main: (await loadResolveExport(resolvePath)) };
+    return (await loadResolveExport(resolvePath));
 }
 /** The module of the company's webhooks (22 §9) at the repository root. */
 export const WEBHOOK_MODULE = 'webhook';
-/** `received` of `webhook.ts`, registered as a `noCase` function of the company part. */
+/** `received` of `webhook.ts`, a function of the company part: `(ctx, { event })`. */
 export async function loadCompanyWebhook(webhookPath) {
     const mod = await importModule(webhookPath);
     const entry = [mod.received, mod.default].find((value) => typeof value === 'function');
     if (!entry)
         throw new Error(`Could not find received export (received | default) as a function in ${webhookPath}`);
-    return { kind: 'noCase', main: entry };
+    return entry;
 }
 /** A name the platform keeps (a sequence's directory, a webhook): letters, numbers and single hyphens. */
 const PLATFORM_NAME = /^[a-zA-Z0-9]+(?:-[a-zA-Z0-9]+)*$/;

package/dist/builder/paths.d.ts

@@ -1,8 +1,13 @@
 /**
- * A TS module may live as `<dir>/<name>.ts` or `<dir>/<name>/index.ts`.
+ * A TS module may live as `<dir>/<name>.ts` or `<dir>/<name>/index.ts`, or `.tsx` (a page in JSX, 31 §10).
  * File form is preferred when both exist.
  */
 export declare function tsModuleCandidates(dir: string, name: string): string[];
+/**
+ * A sequence's page script (15 §10.2): `context.page.ts`, written with functions (76). A page in JSX
+ * (`context.page.tsx`, 31) is no longer one.
+ */
+export declare function requirePagePath(sequenceDir: string, sequenceId: string): string;
 /** Return the first existing candidate, or `undefined` if none exist. */
 export declare function findTsModule(dir: string, name: string): string | undefined;
 /** Return the first existing candidate, or throw with `missingMessage`. */

package/dist/builder/paths.js

@@ -2,11 +2,25 @@ import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { RESOLVE_FUNCTION, RESOLVE_MODULE } from '../core/party/types.js';
 /**
- * A TS module may live as `<dir>/<name>.ts` or `<dir>/<name>/index.ts`.
+ * A TS module may live as `<dir>/<name>.ts` or `<dir>/<name>/index.ts`, or `.tsx` (a page in JSX, 31 §10).
  * File form is preferred when both exist.
  */
 export function tsModuleCandidates(dir, name) {
-    return [path.join(dir, `${name}.ts`), path.join(dir, name, 'index.ts')];
+    return [path.join(dir, `${name}.ts`), path.join(dir, `${name}.tsx`), path.join(dir, name, 'index.ts'), path.join(dir, name, 'index.tsx')];
+}
+/**
+ * A sequence's page script (15 §10.2): `context.page.ts`, written with functions (76). A page in JSX
+ * (`context.page.tsx`, 31) is no longer one.
+ */
+export function requirePagePath(sequenceDir, sequenceId) {
+    const jsx = path.join(sequenceDir, 'context.page.tsx');
+    if (existsSync(jsx)) {
+        throw new Error(`sequences/${sequenceId}/context.page.tsx: a page is written with functions in context.page.ts (76), not JSX: page({ guide }, { name: block({ title }, { … }) }), button({ title, does, action: run(fn.x, { … }) })`);
+    }
+    const page = path.join(sequenceDir, 'context.page.ts');
+    if (!existsSync(page))
+        throw new Error(`sequences/${sequenceId}: context.page.ts is required (the conversation's page, 15 §10.2)`);
+    return page;
 }
 /** Return the first existing candidate, or `undefined` if none exist. */
 export function findTsModule(dir, name) {

package/dist/builder/schedules.d.ts

@@ -1,5 +1,6 @@
 import { type ScheduleDefinition, type ScheduleManifest } from '../core/functions/schedules.js';
 import type { FuncMap, FunctionRegistry } from '../core/functions/types.js';
+import type { FunctionSourceMap } from './types.js';
 /**
  * Why one job's `cron` / `timezone` cannot run, or `null`. The cron is read by the same parser the
  * worker's job scheduler uses (BullMQ's cron-parser); five fields only, so nothing runs every second.
@@ -10,14 +11,15 @@ export declare function parseSchedules(value: unknown, where: string): Record<st
 /** A directory's `schedules.ts`, loaded: what serve runs and what the build records. `null` without the file. */
 export type LoadedSchedules = {
     path: string;
-    /** `schedule.<name>` → the job's `run`, as a `noCase` function. */
+    /** `schedule.<name>` → the job's `run`, a function `(ctx, { schedule })`. */
     functions: FuncMap;
     manifest: ScheduleManifest;
 };
-/** Load and check `<dir>/schedules.ts`; `where` names it in errors (`schedules.ts`, `sequences/pi/schedules.ts`). */
-export declare function loadSchedules(dir: string, where: string): Promise<LoadedSchedules | null>;
-/** The build's registry entries of the jobs: `schedule.<name>` (`code` left out on the serve overlay). */
-export declare function scheduleRegistry(loaded: LoadedSchedules, includeCode: boolean): Promise<FunctionRegistry>;
-/** Authored functions must leave `schedule.*` to `schedules.ts`. */
-export declare function assertNoScheduleNames(names: string[], where: string): void;
+/** Load and check the repository root's `schedules.ts`, the company's only one (25 §6.4). */
+export declare function loadSchedules(repoRoot: string): Promise<LoadedSchedules | null>;
+/**
+ * The build's registry entries of the jobs: `schedule.<name>` (`code` left out on the serve overlay). Each
+ * compiled job's source map goes to `sourceMaps`, by the same name.
+ */
+export declare function scheduleRegistry(loaded: LoadedSchedules, includeCode: boolean, sourceMaps?: Record<string, FunctionSourceMap>): Promise<FunctionRegistry>;
 //# sourceMappingURL=schedules.d.ts.map

package/dist/builder/schedules.js

@@ -1,6 +1,6 @@
 import { pathToFileURL } from 'node:url';
 import { CronExpressionParser } from 'cron-parser';
-import { SCHEDULE_FUNCTION_PREFIX, SCHEDULES_MODULE, scheduleFunctionName, } from '../core/functions/schedules.js';
+import { SCHEDULES_MODULE, scheduleFunctionName, } from '../core/functions/schedules.js';
 import { compileScheduleModuleCode } from './compile/function-code.js';
 import { companyImportGraphHref } from './company-import-graph.js';
 import { findTsModule } from './paths.js';
@@ -68,35 +68,34 @@ async function importSchedules(modulePath, where) {
     const fromDefault = isPlainObject(mod.default) && Object.hasOwn(mod.default, 'schedules') ? mod.default.schedules : mod.default;
     return parseSchedules(mod.schedules ?? fromDefault, where);
 }
-/** Load and check `<dir>/schedules.ts`; `where` names it in errors (`schedules.ts`, `sequences/pi/schedules.ts`). */
-export async function loadSchedules(dir, where) {
-    const modulePath = findTsModule(dir, SCHEDULES_MODULE);
+/** Load and check the repository root's `schedules.ts`, the company's only one (25 §6.4). */
+export async function loadSchedules(repoRoot) {
+    const modulePath = findTsModule(repoRoot, SCHEDULES_MODULE);
     if (!modulePath)
         return null;
-    const schedules = await importSchedules(modulePath, where);
+    const schedules = await importSchedules(modulePath, `${SCHEDULES_MODULE}.ts`);
     const functions = {};
     const manifest = {};
     for (const [name, { cron, timezone, run }] of Object.entries(schedules)) {
-        functions[scheduleFunctionName(name)] = { kind: 'noCase', main: run };
+        functions[scheduleFunctionName(name)] = run;
         manifest[name] = { cron: cron.trim(), timezone };
     }
     return { path: modulePath, functions, manifest };
 }
-/** The build's registry entries of the jobs: `schedule.<name>` (`code` left out on the serve overlay). */
-export async function scheduleRegistry(loaded, includeCode) {
-    const entries = await Promise.all(Object.keys(loaded.manifest).map(async (name) => [
-        scheduleFunctionName(name),
-        includeCode
-            ? { kind: 'noCase', code: await compileScheduleModuleCode(loaded.path, name) }
-            : { kind: 'noCase' },
-    ]));
+/**
+ * The build's registry entries of the jobs: `schedule.<name>` (`code` left out on the serve overlay). Each
+ * compiled job's source map goes to `sourceMaps`, by the same name.
+ */
+export async function scheduleRegistry(loaded, includeCode, sourceMaps) {
+    const entries = await Promise.all(Object.keys(loaded.manifest).map(async (name) => {
+        const fn = scheduleFunctionName(name);
+        if (!includeCode)
+            return [fn, {}];
+        const compiled = await compileScheduleModuleCode(loaded.path, name);
+        if (sourceMaps)
+            sourceMaps[fn] = compiled.map;
+        return [fn, { code: compiled.code }];
+    }));
     return Object.fromEntries(entries);
 }
-/** Authored functions must leave `schedule.*` to `schedules.ts`. */
-export function assertNoScheduleNames(names, where) {
-    const taken = names.filter((name) => name.startsWith(SCHEDULE_FUNCTION_PREFIX));
-    if (taken.length > 0) {
-        throw new Error(`${where} must not define ${taken.map((n) => `'${n}'`).join(', ')}: ${SCHEDULE_FUNCTION_PREFIX}* names are the jobs of ${SCHEDULES_MODULE}.ts`);
-    }
-}
 //# sourceMappingURL=schedules.js.map

package/dist/builder/typecheck.d.ts

@@ -1,5 +1,5 @@
 /**
- * The repository's type check, as `pnpm typecheck` runs it locally: `type:gen`, then `tsc --noEmit`
+ * The repository's type check, as `npm run typecheck` runs it locally: `type:gen`, then `tsc --noEmit`
  * with the repo's own `tsconfig.json`. With no sequence it writes only the root `__gen` (the local
  * `type:gen` needs a sequence). The compile runs it itself, so a type error blocks a release in every
  * environment; the platform never calls the repo's `typecheck` script.