@superpanel-sdk/runtime 0.2.3 → 0.7.0

package/dist/builder/compile/compile-sequence.js

@@ -1,28 +1,27 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { resolveCaseContextViewFn } from '../../core/functions/define/case-context.js';
-import { resolveFuncName } from '../../core/functions/func-ref.js';
 import { compileSlotSchema } from '../../core/slot/compile-schema.js';
+import { subjectTableIssues } from '../../core/slot/company-metadata.js';
+import { ensureCompanyStub, ensureStub } from '../codegen/generate.js';
 import { withCompanyImportGraph } from '../company-import-graph.js';
-import { listSequenceIds, loadCompanySchema, loadSequenceAgendas, loadSequenceCaseContextView, loadSequenceFunctions, loadSequenceSlots, } from '../load.js';
-import { findTsModule, resolveTsModule } from '../paths.js';
-import { compileSequenceAgendas, fatalAgendaIssues } from './compile-agenda.js';
-import { toCaseContextViewRegistry, toFunctionRegistry } from './registry.js';
-const FATAL_CODES = new Set([
-    'unknown-table',
-    'unknown-field',
-    'missing-compute-fn',
-    'cyclic-dependency',
-    'multi-derived-forbidden',
-    'session-derived-forbidden',
-    'unknown-ref-table',
-    'invalid-id-field',
-    'missing-id-field',
-    'id-cannot-ref',
-    'reserved-table-name',
-]);
-/** SequenceBuild / SequenceConfigBuild cache key. Bump when compiled `code` shape changes. */
+import { ORCHESTRATOR_FUNCTION, } from '../../core/case-orchestrator/types.js';
+import { COMPANY_RESOLVE_FUNCTION, RESOLVE_FUNCTION, RESOLVE_MODULE } from '../../core/party/types.js';
+import { compileVariables } from '../../core/sequence/index.js';
+import { WEBHOOK_RECEIVED_FUNCTION } from '../../core/functions/events.js';
+import { SCHEDULES_MODULE } from '../../core/functions/schedules.js';
+import { isPlatformName, listSequenceIds, loadCompanySchema, loadCompanyWebhook, WEBHOOK_MODULE, loadOfficeHours, loadSequenceCaseOrchestrator, loadSequenceEvents, loadSequenceFunctions, loadSequenceDefinition, loadCompanyResolver, loadSequenceResolver, loadSequenceVariables, loadPageModule, loadSessionSchema, assertNoSlotsModule, assertNoChannelsModule, } from '../load.js';
+import { findTsModule, requireCompanyResolveModule, requirePagePath, requireResolveModule, resolveTsModule } from '../paths.js';
+import { fatalSlotSchemaIssues } from '../slot-schema-validation.js';
+import { readFunctionParameters } from '../function-params.js';
+import { typecheckRepo } from '../typecheck.js';
+import { COMPANY_SCOPE, CONTEXT_PAGE_FUNCTION, functionKey, } from '../types.js';
+import { compileExportModuleCode, compilePageModuleCode } from './function-code.js';
+import { loadSchedules, scheduleRegistry } from '../schedules.js';
+import { loadOnError } from '../errors.js';
+import { ERRORS_MODULE, ON_ERROR_FUNCTION } from '../../core/functions/errors.js';
+import { toEventRegistry, toFunctionRegistry } from './registry.js';
+/** SequenceBuild cache key. Bump when compiled `code` shape changes. */
 export function runtimePackageVersion() {
     const pkgPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'package.json');
     const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
@@ -40,101 +39,356 @@ export function runtimePackageSource(repoRoot) {
         return 'npm';
     }
 }
-/** Deep-clone company schema with derived computeFn normalized to string names. */
-export function snapshotCompanySchema(company, functions) {
-    const tables = {};
-    for (const [tableName, table] of Object.entries(company)) {
-        const fields = {};
-        for (const [fieldName, field] of Object.entries(table.fields)) {
-            if (field.derived) {
-                fields[fieldName] = {
-                    ...field,
-                    computeFn: resolveFuncName(field.computeFn, functions),
-                };
-            }
-            else {
-                fields[fieldName] = { ...field };
-            }
-        }
-        tables[tableName] = { ...table, fields };
-    }
-    return tables;
-}
 export function sequenceBuildPath(repoRoot, sequenceId) {
     return path.join(repoRoot, 'sequences', sequenceId, 'build', 'sequence-build.json');
 }
+async function loadCompanySchemas(repoRoot) {
+    const schemaPath = resolveTsModule(repoRoot, 'schema', `No company schema found. Expected schema.ts or schema/index.ts under ${repoRoot}`);
+    return { company: await loadCompanySchema(schemaPath), session: await loadSessionSchema(repoRoot) };
+}
+/** The company schema, compiled; a schema error throws, with every issue in the message. */
+function compileCompanySlotSchema({ company, session }) {
+    const { schema, validation } = compileSlotSchema(company, { session });
+    if (!validation.ok) {
+        const fatal = fatalSlotSchemaIssues(validation.issues);
+        if (fatal.length > 0)
+            throw new Error(fatal.map((issue) => issue.message).join('; '));
+    }
+    return schema;
+}
 export async function compileSequence(repoRoot, sequenceId, options = {}) {
-    return withCompanyImportGraph(repoRoot, () => compileSequenceInGraph(repoRoot, sequenceId, options));
+    return withCompanyImportGraph(repoRoot, async () => {
+        const { schemas: _, ...result } = await compileSequenceInGraph(repoRoot, sequenceId, options);
+        return result;
+    });
+}
+export async function compileSequenceBuild(repoRoot, sequenceId, options = {}) {
+    return withCompanyImportGraph(repoRoot, async () => {
+        const { schemas: _, ...result } = await compileSequenceInGraph(repoRoot, sequenceId, options);
+        return result;
+    });
 }
 async function compileSequenceInGraph(repoRoot, sequenceId, options) {
-    const schemaPath = resolveTsModule(repoRoot, 'schema', `No company schema found. Expected schema.ts or schema/index.ts under ${repoRoot}`);
+    // The directory name is the sequence's identity in every environment (22 §10.2).
+    if (!isPlatformName(sequenceId)) {
+        throw new Error(`sequences/${sequenceId}: a sequence directory is named with letters, numbers and hyphens (at most 40)`);
+    }
     const sequenceDir = path.join(repoRoot, 'sequences', sequenceId);
-    const slotsPath = resolveTsModule(sequenceDir, 'slots', `No sequence slots found. Expected sequences/${sequenceId}/slots.ts or sequences/${sequenceId}/slots/index.ts`);
+    assertNoSlotsModule(sequenceDir, sequenceId);
+    // `functions/index.ts` (or `functions.ts`) is optional: without it the sequence has no functions (76 §5.5).
     const functionsPath = findTsModule(sequenceDir, 'functions');
-    if (!functionsPath) {
-        throw new Error(`No sequence functions found. Expected sequences/${sequenceId}/functions.ts or sequences/${sequenceId}/functions/index.ts`);
-    }
-    const company = await loadCompanySchema(schemaPath);
-    const slots = await loadSequenceSlots(slotsPath);
-    const functions = await loadSequenceFunctions(functionsPath);
-    const viewPath = findTsModule(sequenceDir, 'view');
-    const caseContextView = viewPath ? await loadSequenceCaseContextView(viewPath) : undefined;
-    if (viewPath && !resolveCaseContextViewFn(caseContextView)) {
-        throw new Error(`sequences/${sequenceId}/view.ts did not export a caseContextView function`);
-    }
-    const { schema, validation } = compileSlotSchema(company, slots, {
-        functions,
-        computeFns: new Set(Object.keys(functions)),
-    });
+    // `__gen/` is gitignored in company repos, so a fresh checkout (server-side compile from a git
+    // archive) has no `__gen/index.ts` — which functions.ts / events.ts import at runtime. Write the
+    // missing generated files first; existing ones are left untouched.
+    ensureStub(repoRoot, sequenceId);
+    const schemas = await loadCompanySchemas(repoRoot);
+    const { company, session } = schemas;
+    const authored = functionsPath ? await loadSequenceFunctions(functionsPath) : {};
+    // The conversation follows the page (17b): what to do next is worked out from it, not from an agenda.
+    for (const removed of ['agenda', 'agendas']) {
+        if (findTsModule(sequenceDir, removed)) {
+            throw new Error(`sequences/${sequenceId}/${removed}.ts is no longer supported: the conversation follows the page — write one page function per channel in context.page.ts`);
+        }
+    }
+    const caseOrchestratorPath = findTsModule(sequenceDir, 'orchestrator');
+    if (Object.hasOwn(authored, ORCHESTRATOR_FUNCTION)) {
+        throw new Error(`functions must not define '${ORCHESTRATOR_FUNCTION}'; it is the Case Orchestrator's, from orchestrator.ts`);
+    }
+    for (const reserved of [RESOLVE_FUNCTION, COMPANY_RESOLVE_FUNCTION]) {
+        if (Object.hasOwn(authored, reserved)) {
+            throw new Error(`functions must not define '${reserved}'; it is a resolver in ${RESOLVE_MODULE}.ts`);
+        }
+    }
+    // The page script is known by this name among the sequence's functions (`functionKey`).
+    if (Object.hasOwn(authored, CONTEXT_PAGE_FUNCTION)) {
+        throw new Error(`functions must not define '${CONTEXT_PAGE_FUNCTION}'; it is the page script's name (context.page.ts)`);
+    }
+    // Recurring jobs are the company's only (25 §6.4): the repository root's schedules.ts.
+    if (findTsModule(sequenceDir, SCHEDULES_MODULE)) {
+        throw new Error(`sequences/${sequenceId}/${SCHEDULES_MODULE}.ts is not supported: recurring jobs go in the repository root's ${SCHEDULES_MODULE}.ts (import the sequence's functions from there) (25 §6.4)`);
+    }
+    // onError is the company's only (67 §5): the repository root's errors.ts.
+    if (findTsModule(sequenceDir, ERRORS_MODULE)) {
+        throw new Error(`sequences/${sequenceId}/${ERRORS_MODULE}.ts is not supported: onError goes in the repository root's ${ERRORS_MODULE}.ts (67 §5)`);
+    }
+    if (findTsModule(sequenceDir, 'party')) {
+        throw new Error(`sequences/${sequenceId}/party.ts is no longer supported: export ${RESOLVE_FUNCTION} from sequences/${sequenceId}/${RESOLVE_MODULE}.ts`);
+    }
+    const resolvePath = requireResolveModule(sequenceDir, sequenceId);
+    const resolver = await loadSequenceResolver(resolvePath);
+    const caseOrchestratorFn = caseOrchestratorPath ? await loadSequenceCaseOrchestrator(caseOrchestratorPath) : null;
+    const functions = {
+        ...authored,
+        [RESOLVE_FUNCTION]: resolver,
+        ...(caseOrchestratorFn ? { [ORCHESTRATOR_FUNCTION]: caseOrchestratorFn } : {}),
+    };
+    const eventsPath = findTsModule(sequenceDir, 'events');
+    const events = eventsPath ? await loadSequenceEvents(eventsPath) : {};
+    const collisions = Object.keys(functions).filter((name) => Object.hasOwn(events, name));
+    if (collisions.length > 0) {
+        throw new Error(`functions and events must not share names: ${collisions.join(', ')}`);
+    }
+    // The Orchestrator reads with `ctx.api.db` (15 §10.16): no view.
+    if (findTsModule(sequenceDir, 'view')) {
+        throw new Error(`sequences/${sequenceId}/view.ts is no longer supported: the Orchestrator reads with ctx.api.db, and names who a Run may contact with contacts in orchestrator.ts`);
+    }
+    // The conversation's page is the page script, always (15 §10.2): no default page.
+    const pagePath = requirePagePath(sequenceDir, sequenceId);
+    // The page's actions (76 §2.11): `actions.ts`, optional, like `functions/`.
+    const actionsPath = findTsModule(sequenceDir, 'actions') ?? null;
+    // The FAQ is the page's (24 §7): `faq` in definePage, called when the conversation starts.
+    if (findTsModule(sequenceDir, 'knowledge')) {
+        throw new Error(`sequences/${sequenceId}/knowledge.ts is no longer supported: return the FAQ from definePage({ faq: (ctx) => [...] }) in context.page.ts (24 §7)`);
+    }
+    const { subject, label } = await loadSequenceDefinition(sequenceDir);
+    // One schema for the whole company (28 §2): the sequence only names its subject.
+    const { schema, validation } = compileSlotSchema(company, { session });
+    const subjectIssues = subjectTableIssues(company, subject);
+    if (subjectIssues.length > 0)
+        throw new Error(subjectIssues.map((i) => i.message).join('; '));
     if (!validation.ok) {
-        const fatal = validation.issues.filter((i) => FATAL_CODES.has(i.code));
+        const fatal = fatalSlotSchemaIssues(validation.issues);
         if (fatal.length > 0) {
             throw new Error(fatal.map((i) => i.message).join('; '));
         }
     }
-    const agendasPath = findTsModule(sequenceDir, 'agendas');
-    const rawAgendas = agendasPath ? await loadSequenceAgendas(agendasPath) : null;
-    const compiledAgendas = compileSequenceAgendas(schema, rawAgendas, { functions });
-    const fatalAgenda = fatalAgendaIssues(compiledAgendas.issues);
-    if (fatalAgenda.length > 0) {
-        throw new Error(fatalAgenda.map((i) => i.message).join('; '));
+    const declared = await loadSequenceVariables(sequenceDir);
+    const variables = compileVariables(declared.variables, declared.experiments);
+    if (variables.issues.length > 0) {
+        throw new Error(`sequences/${sequenceId}/variables.ts: ${variables.issues.join('; ')}`);
+    }
+    // The declarative load was removed (15 §10.15): the conversation reads in context.page.ts.
+    if (findTsModule(sequenceDir, 'load')) {
+        throw new Error(`sequences/${sequenceId}/load.ts: declarative load is no longer supported; read with db in context.page.ts`);
     }
+    const orchestrator = caseOrchestratorFn ? { fn: ORCHESTRATOR_FUNCTION } : null;
     const includeCode = options.includeCode ?? true;
-    const [functionsRegistry, caseContextViewEntry] = await Promise.all([
-        toFunctionRegistry(functions, { includeCode, modulePath: functionsPath }),
-        toCaseContextViewRegistry(caseContextView, { includeCode, modulePath: viewPath }),
+    const functionMaps = {};
+    const [functionsRegistry, resolveCompiled, caseOrchestratorCompiled, eventsRegistry, page,] = await Promise.all([
+        toFunctionRegistry(authored, { includeCode, ...(functionsPath ? { modulePath: functionsPath } : {}), sourceMaps: functionMaps }),
+        includeCode ? compileExportModuleCode(resolvePath, RESOLVE_FUNCTION) : Promise.resolve(undefined),
+        caseOrchestratorPath && includeCode
+            ? compileExportModuleCode(caseOrchestratorPath, ORCHESTRATOR_FUNCTION)
+            : Promise.resolve(undefined),
+        toEventRegistry(events, { includeCode, modulePath: eventsPath, sourceMaps: functionMaps }),
+        compilePageModuleCode(pagePath, actionsPath),
     ]);
+    const resolveCode = codeKeepingMap(RESOLVE_FUNCTION, resolveCompiled, functionMaps);
+    const caseOrchestratorCode = codeKeepingMap(ORCHESTRATOR_FUNCTION, caseOrchestratorCompiled, functionMaps);
+    const pageCode = page.code;
+    const { channels, actions: actionNames } = loadPageModule(pageCode, sequenceId);
+    const runtimeVersion = runtimePackageVersion();
     const build = {
         sequenceId,
-        sha: options.sha ?? 'local',
-        engineVersion: runtimePackageVersion(),
+        label: typeof label === 'string' && label.trim() ? label.trim() : sequenceId,
+        engineVersion: runtimeVersion,
+        runtimeVersion,
         runtimeSource: options.runtimeSource ?? runtimePackageSource(repoRoot),
-        compiledAt: new Date().toISOString(),
-        companySchemaSnapshot: snapshotCompanySchema(company, functions),
-        schema: compiledAgendas.schema,
-        effectiveSchema: compiledAgendas.effectiveSchema,
-        functions: functionsRegistry,
-        caseContextView: caseContextViewEntry,
-        agendas: compiledAgendas.agendas,
+        subject: subject,
+        variables: variables.variables,
+        experiments: variables.experiments,
+        functions: {
+            ...functionsRegistry,
+            [RESOLVE_FUNCTION]: resolveCode === undefined ? {} : { code: resolveCode },
+            ...(caseOrchestratorPath ? { [ORCHESTRATOR_FUNCTION]: caseOrchestratorCode === undefined ? {} : { code: caseOrchestratorCode } } : {}),
+        },
+        events: eventsRegistry,
+        officeHours: await loadOfficeHours(sequenceDir),
+        orchestrator,
+        contextPage: { code: pageCode, channels, ...functionParameters(authored, functionsPath), ...actionParameters(actionsPath, actionNames, sequenceId) },
     };
     const outPath = sequenceBuildPath(repoRoot, sequenceId);
     if (!options.dryRun) {
         mkdirSync(path.dirname(outPath), { recursive: true });
         writeFileSync(outPath, `${JSON.stringify(build, null, 2)}\n`, 'utf8');
     }
-    return { sequenceId, outPath, build, wrote: !options.dryRun };
+    return {
+        sequenceId,
+        outPath,
+        build,
+        schema,
+        schemas,
+        sourceMaps: keyedMaps(sequenceId, { ...functionMaps, [CONTEXT_PAGE_FUNCTION]: page.map }),
+        wrote: !options.dryRun,
+    };
+}
+/** Maps by name in `scope`, keyed as the platform knows the code: its {@link functionKey}. */
+function keyedMaps(scope, byName) {
+    return Object.fromEntries(Object.entries(byName).map(([name, map]) => [functionKey(scope, name), map]));
+}
+/** A compiled function's code, its map kept in `maps` by the function's name; nothing when not compiled. */
+function codeKeepingMap(name, compiled, maps) {
+    if (!compiled)
+        return undefined;
+    maps[name] = compiled.map;
+    return compiled.code;
 }
 export async function compileAll(repoRoot, options = {}) {
     return withCompanyImportGraph(repoRoot, async () => {
         const ids = options.sequenceIds ?? listSequenceIds(repoRoot);
         if (ids.length === 0) {
-            throw new Error(`No sequences with slots found under ${path.join(repoRoot, 'sequences')} (expected slots.ts or slots/index.ts)`);
+            throw new Error(`No sequences found under ${path.join(repoRoot, 'sequences')} (a sequence is a directory with index.ts)`);
         }
+        compileCompanySlotSchema(await loadCompanySchemas(repoRoot));
         const results = [];
         for (const sequenceId of ids) {
-            results.push(await compileSequence(repoRoot, sequenceId, options));
+            const { schemas: _, ...result } = await compileSequenceInGraph(repoRoot, sequenceId, options);
+            results.push(result);
         }
         return results;
     });
 }
+/**
+ * The company part of the company build (22 §5): the root `resolve.ts` as `companyResolve`, the root
+ * `webhook.ts` as `webhook.received`, the root `schedules.ts` as `schedule.<name>` (25 §6.4), the root
+ * `errors.ts` as `onError` (67 §5), and the
+ * company schema with no subject. An error in it fails the
+ * whole compile.
+ */
+export async function compileCompanyPart(repoRoot, options = {}) {
+    return (await compileCompanyPartWithMaps(repoRoot, options)).part;
+}
+/** {@link compileCompanyPart}, with the source maps of its functions by `functionKey` (kept apart from the build). */
+async function compileCompanyPartWithMaps(repoRoot, options) {
+    return withCompanyImportGraph(repoRoot, async () => {
+        const includeCode = options.includeCode ?? true;
+        // `resolve.ts` and `webhook.ts` import the root `__gen/`, which a fresh checkout does not have.
+        ensureCompanyStub(repoRoot);
+        // The schema first: an error in it fails the compile before any company code loads.
+        const schema = compileCompanySlotSchema(await loadCompanySchemas(repoRoot));
+        const companyResolvePath = requireCompanyResolveModule(repoRoot);
+        await loadCompanyResolver(companyResolvePath);
+        assertNoChannelsModule(repoRoot);
+        const webhookPath = findTsModule(repoRoot, WEBHOOK_MODULE);
+        if (webhookPath)
+            await loadCompanyWebhook(webhookPath);
+        const schedules = await loadSchedules(repoRoot);
+        const onError = await loadOnError(repoRoot);
+        const sourceMaps = {};
+        const [resolveCompiled, webhookCompiled, schedulesRegistry, onErrorCompiled] = await Promise.all([
+            includeCode ? compileExportModuleCode(companyResolvePath, RESOLVE_FUNCTION) : Promise.resolve(undefined),
+            includeCode && webhookPath ? compileExportModuleCode(webhookPath, 'received') : Promise.resolve(undefined),
+            schedules ? scheduleRegistry(schedules, includeCode, sourceMaps) : Promise.resolve({}),
+            includeCode && onError ? compileExportModuleCode(onError.path, ON_ERROR_FUNCTION) : Promise.resolve(undefined),
+        ]);
+        const entry = (name, compiled) => {
+            const code = codeKeepingMap(name, compiled, sourceMaps);
+            return code === undefined ? {} : { code };
+        };
+        const part = {
+            functions: {
+                [COMPANY_RESOLVE_FUNCTION]: entry(COMPANY_RESOLVE_FUNCTION, resolveCompiled),
+                ...(webhookPath ? { [WEBHOOK_RECEIVED_FUNCTION]: entry(WEBHOOK_RECEIVED_FUNCTION, webhookCompiled) } : {}),
+                ...schedulesRegistry,
+                ...(onError ? { [ON_ERROR_FUNCTION]: entry(ON_ERROR_FUNCTION, onErrorCompiled) } : {}),
+            },
+            ...(schedules ? { schedules: schedules.manifest } : {}),
+            schema,
+            runtimeVersion: runtimePackageVersion(),
+            runtimeSource: options.runtimeSource ?? runtimePackageSource(repoRoot),
+        };
+        return { part, sourceMaps: keyedMaps(COMPANY_SCOPE, sourceMaps) };
+    });
+}
+export const COMPILE_CONCURRENCY = 4;
+export const COMPILE_SEQUENCE_TIMEOUT_MS = 5 * 60_000;
+function withDeadline(work, ms, message) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(message)), ms);
+        work.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+async function mapPool(items, limit, run) {
+    if (items.length === 0)
+        return;
+    let cursor = 0;
+    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+        while (cursor < items.length) {
+            const item = items[cursor];
+            cursor += 1;
+            if (item === undefined)
+                return;
+            await run(item);
+        }
+    });
+    await Promise.all(workers);
+}
+/**
+ * Compile the company part (its schema first) once, then every named sequence in this process, then
+ * type-check the repository. A sequence error is collected; a company schema error or a type error
+ * rejects the whole call, a type error with the tsc output as its message.
+ */
+export async function compileRepo(repoRoot, options) {
+    return withCompanyImportGraph(repoRoot, async () => {
+        const runtimeSource = options.runtimeSource ?? runtimePackageSource(repoRoot);
+        const { part: company, sourceMaps: companySourceMaps } = await compileCompanyPartWithMaps(repoRoot, {
+            includeCode: true,
+            runtimeSource,
+        });
+        options.onEvent?.({
+            type: 'log',
+            text: `Repo build runtime: ${runtimePackageVersion()} (${runtimeSource})`,
+        });
+        const timeoutMs = options.sequenceTimeoutMs ?? COMPILE_SEQUENCE_TIMEOUT_MS;
+        const sequences = {};
+        await mapPool(options.sequences, options.concurrency ?? COMPILE_CONCURRENCY, async (sequenceId) => {
+            options.onEvent?.({ type: 'sequence-started', sequence: sequenceId });
+            options.onEvent?.({ type: 'log', sequence: sequenceId, text: `Compiling ${sequenceId}...` });
+            try {
+                const result = await withDeadline(compileSequenceInGraph(repoRoot, sequenceId, {
+                    dryRun: true,
+                    runtimeSource,
+                    includeCode: true,
+                }), timeoutMs, `compile timed out after ${Math.round(timeoutMs / 60_000)} minutes`);
+                sequences[sequenceId] = { ok: true, build: result.build, sourceMaps: result.sourceMaps };
+                options.onEvent?.({ type: 'log', sequence: sequenceId, text: `Compiled ${sequenceId}` });
+                options.onEvent?.({ type: 'sequence-finished', sequence: sequenceId, ok: true });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                sequences[sequenceId] = { ok: false, error: message };
+                options.onEvent?.({ type: 'sequence-finished', sequence: sequenceId, ok: false, error: message });
+            }
+        });
+        // A failed sequence already fails the release, and type:gen would only repeat its error.
+        if (Object.values(sequences).every((outcome) => outcome.ok)) {
+            await typecheckRepo(repoRoot, (text) => options.onEvent?.({ type: 'log', text }));
+        }
+        return { company, companySourceMaps, sequences };
+    });
+}
+/** The page actions' parameters, from their `args` types (76 §2.11): `actions` of `actions.ts`, as functions' are read; nothing without. */
+function actionParameters(actionsPath, names, sequenceId) {
+    if (!actionsPath || names.length === 0)
+        return {};
+    const typed = readFunctionParameters(actionsPath, 'actions');
+    const out = {};
+    for (const name of names) {
+        const parameters = Object.hasOwn(typed, name) ? typed[name] : undefined;
+        if (!parameters)
+            throw new Error(`sequences/${sequenceId}/${path.basename(actionsPath)}: actions.${name}: the type checker does not see it as a function`);
+        out[name] = { parameters };
+    }
+    return { actions: out };
+}
+/** The functions' parameters, from their `args` types (38 §2.4), for the page's function buttons; nothing without functions. */
+function functionParameters(functions, functionsPath) {
+    if (!functionsPath || Object.keys(functions).length === 0)
+        return {};
+    const typed = readFunctionParameters(functionsPath, 'functions');
+    const out = {};
+    for (const name of Object.keys(functions)) {
+        const parameters = Object.hasOwn(typed, name) ? typed[name] : undefined;
+        if (!parameters)
+            throw new Error(`${functionsPath}: functions.${name}: the type checker does not see it as a function`);
+        out[name] = { parameters };
+    }
+    return { functions: out };
+}
 //# sourceMappingURL=compile-sequence.js.map

package/dist/builder/compile/function-code.d.ts

@@ -1,10 +1,26 @@
+import type { FunctionSourceMap } from '../types.js';
 /**
  * Compile a single function implementation to a standalone JS expression string
  * suitable for QuickJS `eval` / registry `code` fields (minified).
  */
 export declare function compileFunctionCode(fn: (...args: never[]) => unknown): Promise<string>;
+/** A function's or page script's compiled code, and where its positions were in the company's files. */
+export type CompiledModule = {
+    code: string;
+    map: FunctionSourceMap;
+};
 /** Bundle one registered function with module-local helpers and constants. */
-export declare function compileFunctionModuleCode(modulePath: string, functionName: string): Promise<string>;
-/** Bundle caseContextView with module-local helpers and constants. */
-export declare function compileCaseContextViewModuleCode(modulePath: string): Promise<string>;
+export declare function compileFunctionModuleCode(modulePath: string, functionName: string): Promise<CompiledModule>;
+/** Bundle one event handler (a plain function under the `events` export) with module-local helpers. */
+export declare function compileEventModuleCode(modulePath: string, eventName: string): Promise<CompiledModule>;
+/** Bundle one job's `run` of a `schedules.ts` (25 §6.4) with module-local helpers. */
+export declare function compileScheduleModuleCode(modulePath: string, scheduleName: string): Promise<CompiledModule>;
+/** Bundle a module's named export (a function) with its helpers. */
+export declare function compileExportModuleCode(modulePath: string, exportName: string): Promise<CompiledModule>;
+/**
+ * Bundle a sequence's page script (`context.page.ts`, 15 §10.2) with its helpers, and its page actions
+ * (`actions.ts`, 76 §2.11) when it has them: the result evaluates to `pageEntry(module, actions)`, which
+ * renders the page or runs one of its actions (`core/page/define.ts`).
+ */
+export declare function compilePageModuleCode(modulePath: string, actionsPath?: string | null): Promise<CompiledModule>;
 //# sourceMappingURL=function-code.d.ts.map