@superpanel-sdk/runtime 0.2.3 → 0.5.0

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

@@ -1,28 +1,22 @@
 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 { compileCompanyMetadata, 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_CONTACTS_FUNCTION, 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 { isPlatformName, listSequenceIds, loadCompanySchema, loadCompanyWebhook, WEBHOOK_MODULE, loadOfficeHours, loadSequenceCaseOrchestrator, loadSequenceEvents, loadSequenceFunctions, loadSequenceDefinition, loadCompanyResolver, loadSequenceResolver, loadSequenceVariables, loadPageChannels, loadSessionSchema, assertNoSlotsModule, assertNoChannelsModule, } from '../load.js';
+import { findTsModule, requireCompanyResolveModule, requireResolveModule, resolveTsModule } from '../paths.js';
+import { fatalSlotSchemaIssues } from '../slot-schema-validation.js';
+import { typecheckRepo } from '../typecheck.js';
+import { compileExportModuleCode, compilePageModuleCode } from './function-code.js';
+import { assertNoScheduleNames, loadSchedules, scheduleRegistry } from '../schedules.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 +34,309 @@ 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) };
+}
+function compileMetadata({ company, session }) {
+    const result = compileCompanyMetadata(company, session);
+    if (!result.validation.ok || !result.metadata) {
+        throw new Error(result.validation.ok
+            ? 'invalid company metadata'
+            : result.validation.issues.map((issue) => issue.message).join('; '));
+    }
+    return result.metadata;
+}
+export async function compileCompanyMetadataFromRepo(repoRoot) {
+    return withCompanyImportGraph(repoRoot, async () => compileMetadata(await loadCompanySchemas(repoRoot)));
+}
 export async function compileSequence(repoRoot, sequenceId, options = {}) {
-    return withCompanyImportGraph(repoRoot, () => compileSequenceInGraph(repoRoot, sequenceId, options));
+    return withCompanyImportGraph(repoRoot, async () => {
+        const result = await compileSequenceInGraph(repoRoot, sequenceId, options);
+        const { schemas, ...build } = result;
+        return { ...build, companyMetadata: compileMetadata(schemas) };
+    });
+}
+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);
     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 = 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');
+    for (const reserved of [ORCHESTRATOR_FUNCTION, ORCHESTRATOR_CONTACTS_FUNCTION]) {
+        if (Object.hasOwn(authored, reserved)) {
+            throw new Error(`functions must not define '${reserved}'; 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`);
+        }
+    }
+    assertNoScheduleNames(Object.keys(authored), `sequences/${sequenceId}/functions`);
+    // The sequence's recurring jobs (25 §6.4): `schedule.<name>` functions, timed by `schedules`.
+    const schedules = await loadSchedules(sequenceDir, `sequences/${sequenceId}/schedules.ts`);
+    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]: { kind: 'orchestrator', main: caseOrchestratorFn.orchestrator },
+                [ORCHESTRATOR_CONTACTS_FUNCTION]: { kind: 'orchestrator', main: caseOrchestratorFn.contacts },
+            }
+            : {}),
+    };
+    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 = findTsModule(sequenceDir, 'context.page');
+    if (!pagePath) {
+        throw new Error(`sequences/${sequenceId}: context.page.ts is required (the conversation's page, 15 §10.2)`);
+    }
+    // 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, contactsFn: ORCHESTRATOR_CONTACTS_FUNCTION }
+        : null;
     const includeCode = options.includeCode ?? true;
-    const [functionsRegistry, caseContextViewEntry] = await Promise.all([
-        toFunctionRegistry(functions, { includeCode, modulePath: functionsPath }),
-        toCaseContextViewRegistry(caseContextView, { includeCode, modulePath: viewPath }),
+    const [functionsRegistry, resolveCode, caseOrchestratorCode, caseOrchestratorContactsCode, eventsRegistry, pageCode, schedulesRegistry,] = await Promise.all([
+        toFunctionRegistry(authored, { includeCode, modulePath: functionsPath }),
+        includeCode ? compileExportModuleCode(resolvePath, RESOLVE_FUNCTION) : Promise.resolve(undefined),
+        caseOrchestratorPath && includeCode
+            ? compileExportModuleCode(caseOrchestratorPath, ORCHESTRATOR_FUNCTION)
+            : Promise.resolve(undefined),
+        caseOrchestratorPath && includeCode ? compileExportModuleCode(caseOrchestratorPath, 'contacts') : Promise.resolve(undefined),
+        toEventRegistry(events, { includeCode, modulePath: eventsPath }),
+        compilePageModuleCode(pagePath),
+        schedules ? scheduleRegistry(schedules, includeCode) : Promise.resolve({}),
     ]);
+    const channels = loadPageChannels(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 ? { kind: 'noCase' } : { kind: 'noCase', code: resolveCode },
+            ...(caseOrchestratorPath
+                ? {
+                    [ORCHESTRATOR_FUNCTION]: caseOrchestratorCode === undefined
+                        ? { kind: 'orchestrator' }
+                        : { kind: 'orchestrator', code: caseOrchestratorCode },
+                    [ORCHESTRATOR_CONTACTS_FUNCTION]: caseOrchestratorContactsCode === undefined
+                        ? { kind: 'orchestrator' }
+                        : { kind: 'orchestrator', code: caseOrchestratorContactsCode },
+                }
+                : {}),
+            ...schedulesRegistry,
+        },
+        events: eventsRegistry,
+        officeHours: await loadOfficeHours(sequenceDir),
+        orchestrator,
+        contextPage: { code: pageCode, channels },
+        ...(schedules ? { schedules: schedules.manifest } : {}),
     };
     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, wrote: !options.dryRun };
 }
 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)`);
         }
+        const companyMetadata = compileMetadata(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, companyMetadata });
         }
         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), and the
+ * company schema with no subject. An error in it fails the
+ * whole compile.
+ */
+export async function compileCompanyPart(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);
+        const { company, session } = 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, 'schedules.ts');
+        const [resolveCode, webhookCode, schedulesRegistry] = await Promise.all([
+            includeCode ? compileExportModuleCode(companyResolvePath, RESOLVE_FUNCTION) : Promise.resolve(undefined),
+            includeCode && webhookPath ? compileExportModuleCode(webhookPath, 'received') : Promise.resolve(undefined),
+            schedules ? scheduleRegistry(schedules, includeCode) : Promise.resolve({}),
+        ]);
+        const entry = (code) => (code === undefined ? { kind: 'noCase' } : { kind: 'noCase', code });
+        const { schema } = compileSlotSchema(company, { session });
+        return {
+            functions: {
+                [COMPANY_RESOLVE_FUNCTION]: entry(resolveCode),
+                ...(webhookPath ? { [WEBHOOK_RECEIVED_FUNCTION]: entry(webhookCode) } : {}),
+                ...schedulesRegistry,
+            },
+            ...(schedules ? { schedules: schedules.manifest } : {}),
+            schema,
+            runtimeVersion: runtimePackageVersion(),
+            runtimeSource: options.runtimeSource ?? runtimePackageSource(repoRoot),
+        };
+    });
+}
+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 company metadata 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 companyMetadata = compileMetadata(await loadCompanySchemas(repoRoot));
+        const runtimeSource = options.runtimeSource ?? runtimePackageSource(repoRoot);
+        const company = await compileCompanyPart(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 };
+                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 { companyMetadata, company, sequences };
+    });
+}
 //# sourceMappingURL=compile-sequence.js.map

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

@@ -5,6 +5,16 @@
 export declare function compileFunctionCode(fn: (...args: never[]) => unknown): Promise<string>;
 /** 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>;
+/** Bundle one event handler (a plain function under the `events` export) with module-local helpers. */
+export declare function compileEventModuleCode(modulePath: string, eventName: string): Promise<string>;
+/** 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<string>;
+/** Bundle a module's named export (a plain function, or a `define*` result's `main`) with its helpers. */
+export declare function compileExportModuleCode(modulePath: string, exportName: string): Promise<string>;
+/**
+ * Bundle a sequence's page script (`context.page.ts`, 15 §10.2) with its helpers and the page module:
+ * the result evaluates to `pageEntry(module)`, which renders the page or runs one of its actions
+ * (`core/page/define.ts`).
+ */
+export declare function compilePageModuleCode(modulePath: string): Promise<string>;
 //# sourceMappingURL=function-code.d.ts.map

package/dist/builder/compile/function-code.js

@@ -1,35 +1,62 @@
 import * as esbuild from 'esbuild';
+import { existsSync } from 'node:fs';
 import path from 'node:path';
-const RUNTIME_SHIM_NAMESPACE = 'superpanel-runtime-shim';
-const RUNTIME_SHIM = `
-export function defineComputeFunc(main, options) {
-  return { kind: 'compute', main, ...options };
-}
-export function defineBoolComputeFunc(main, options) {
-  return { kind: 'boolCompute', main, ...options };
-}
-export function defineCustomFunc(main, options) {
-  return { kind: 'custom', main, ...options };
-}
-export function defineSystemFunc(main, options) {
-  return { kind: 'system', main, ...options };
-}
-export function defineCaseContext(main) {
-  return Object.assign(main, { kind: 'caseContextView', main });
+import { fileURLToPath } from 'node:url';
+import { companyRepoRoot } from '../company-import-graph.js';
+import { RUNTIME_PACKAGE, companyImportError, packageRootOf, realPath, resolvedIssue, specifierIssue, } from '../company-imports.js';
+/**
+ * A module of this runtime as a bundle takes it: `<name>.js` next to this module in the published
+ * package, `<name>.ts` in the source tree.
+ */
+function runtimeModule(name) {
+    const base = path.resolve(path.dirname(fileURLToPath(import.meta.url)), `../../${name}`);
+    return existsSync(`${base}.js`) ? `${base}.js` : `${base}.ts`;
 }
-`;
-function runtimeShimPlugin() {
+/** The bundle's entry: the compile's own code next to the company module, importing it. */
+const ENTRY_FILE = 'superpanel-function-entry.ts';
+/** Marks a resolve the plugin asked for itself, so it does not check its own request. */
+const CHECKED = Symbol('company import checked');
+/**
+ * Checks every import a company file makes (company-imports.ts) and bundles `@superpanel-sdk/runtime` as
+ * this runtime's own company API (`src/index.ts`): a code string carries the helpers of the runtime that
+ * compiled it, whichever copy the repository would resolve, and keeps of them only what it uses.
+ */
+function companyImportsPlugin(repoRoot, entryFile) {
+    const root = realPath(repoRoot);
+    const isCompanyFile = (file) => {
+        // The entry is the compile's own (it picks the export and the page's `pageEntry`), not the company's.
+        if (!path.isAbsolute(file) || file === entryFile)
+            return false;
+        const relative = path.relative(root, realPath(file));
+        return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative) && !relative.split(path.sep).includes('node_modules');
+    };
     return {
-        name: 'superpanel-runtime-shim',
+        name: 'superpanel-company-imports',
         setup(build) {
-            build.onResolve({ filter: /^@superpanel-sdk\/runtime$/ }, () => ({
-                path: 'runtime',
-                namespace: RUNTIME_SHIM_NAMESPACE,
-            }));
-            build.onLoad({ filter: /.*/, namespace: RUNTIME_SHIM_NAMESPACE }, () => ({
-                contents: RUNTIME_SHIM,
-                loader: 'js',
-            }));
+            build.onResolve({ filter: /.*/ }, async (args) => {
+                if (args.pluginData === CHECKED || !isCompanyFile(args.importer))
+                    return undefined;
+                const refuse = (issue) => ({
+                    errors: [{ text: companyImportError(args.importer, repoRoot, issue).message }],
+                });
+                const issue = specifierIssue(args.path);
+                if (issue)
+                    return refuse(issue);
+                if (args.path === RUNTIME_PACKAGE)
+                    return { path: runtimeModule('index') };
+                const resolved = await build.resolve(args.path, {
+                    kind: args.kind,
+                    importer: args.importer,
+                    resolveDir: args.resolveDir,
+                    pluginData: CHECKED,
+                });
+                if (resolved.errors.length > 0)
+                    return { errors: resolved.errors };
+                const resolvedProblem = resolvedIssue(args.path, resolved.path, repoRoot);
+                if (resolvedProblem)
+                    return refuse(resolvedProblem);
+                return { path: resolved.path, namespace: resolved.namespace, sideEffects: resolved.sideEffects, suffix: resolved.suffix };
+            });
         },
     };
 }
@@ -48,11 +75,10 @@ export async function compileFunctionCode(fn) {
     });
     const text = result.code.trim();
     if (text.includes('@superpanel-sdk/runtime') ||
-        text.includes('defineComputeFunc') ||
-        text.includes('defineCustomFunc') ||
-        text.includes('defineBoolComputeFunc') ||
-        text.includes('defineSystemFunc') ||
-        text.includes('defineCaseContext')) {
+        text.includes('defineCaseFunc') ||
+        text.includes('defineNoCaseFunc') ||
+        text.includes('defineEvents') ||
+        text.includes('bindDefines')) {
         throw new Error('compiled function code still references define* / @superpanel-sdk/runtime');
     }
     const m = /^export\s+default\s*/.exec(text);
@@ -61,14 +87,18 @@ export async function compileFunctionCode(fn) {
     }
     return text.slice(m[0].length).replace(/;?\s*$/, '');
 }
-async function compileModuleSelection(modulePath, selection) {
+async function compileModuleSelection(modulePath, selection, imports = '') {
+    // The compile bundles inside its import graph; a caller outside one (a test) bundles within the module's package.
+    const repoRoot = companyRepoRoot() ?? packageRootOf(modulePath);
+    const entryFile = path.join(path.dirname(modulePath), ENTRY_FILE);
     const result = await esbuild.build({
         stdin: {
             contents: `import * as mod from ${JSON.stringify(modulePath)};
+${imports}
 const selected = ${selection};
 export default selected;`,
             resolveDir: path.dirname(modulePath),
-            sourcefile: 'superpanel-function-entry.ts',
+            sourcefile: ENTRY_FILE,
             loader: 'ts',
         },
         bundle: true,
@@ -79,7 +109,7 @@ export default selected;`,
         target: 'es2022',
         minify: true,
         logLevel: 'silent',
-        plugins: [runtimeShimPlugin()],
+        plugins: [companyImportsPlugin(repoRoot, entryFile)],
     });
     const output = result.outputFiles[0]?.text.trim();
     if (!output) {
@@ -92,9 +122,27 @@ export function compileFunctionModuleCode(modulePath, functionName) {
     const registry = `(mod.functions ?? mod.default?.functions ?? mod.default)`;
     return compileModuleSelection(modulePath, `${registry}[${JSON.stringify(functionName)}].main`);
 }
-/** Bundle caseContextView with module-local helpers and constants. */
-export function compileCaseContextViewModuleCode(modulePath) {
-    const view = `(mod.caseContextView ?? mod.default?.caseContextView ?? mod.default)`;
-    return compileModuleSelection(modulePath, `(${view}.main ?? ${view})`);
+/** Bundle one event handler (a plain function under the `events` export) with module-local helpers. */
+export function compileEventModuleCode(modulePath, eventName) {
+    const registry = `(mod.events ?? mod.default?.events ?? mod.default)`;
+    return compileModuleSelection(modulePath, `${registry}[${JSON.stringify(eventName)}]`);
+}
+/** Bundle one job's `run` of a `schedules.ts` (25 §6.4) with module-local helpers. */
+export function compileScheduleModuleCode(modulePath, scheduleName) {
+    const registry = `(mod.schedules ?? mod.default?.schedules ?? mod.default)`;
+    return compileModuleSelection(modulePath, `${registry}[${JSON.stringify(scheduleName)}].run`);
+}
+/** Bundle a module's named export (a plain function, or a `define*` result's `main`) with its helpers. */
+export function compileExportModuleCode(modulePath, exportName) {
+    const entry = `(mod[${JSON.stringify(exportName)}] ?? mod.default)`;
+    return compileModuleSelection(modulePath, `(${entry}.main ?? ${entry})`);
+}
+/**
+ * Bundle a sequence's page script (`context.page.ts`, 15 §10.2) with its helpers and the page module:
+ * the result evaluates to `pageEntry(module)`, which renders the page or runs one of its actions
+ * (`core/page/define.ts`).
+ */
+export function compilePageModuleCode(modulePath) {
+    return compileModuleSelection(modulePath, 'pageEntry(mod)', `import { pageEntry } from ${JSON.stringify(runtimeModule('core/page/define'))};`);
 }
 //# sourceMappingURL=function-code.js.map

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

@@ -1,4 +1,5 @@
-import type { CaseContextViewRegistryEntry, FuncMap, FunctionRegistry } from '../../core/functions/types.js';
+import { type AnyEventHandlers } from '../../core/functions/events.js';
+import type { FuncMap, FunctionRegistry } from '../../core/functions/types.js';
 export type BuildRegistryOptions = {
     /** When false, skip esbuild and omit `code` (local serve overlay). Default true. */
     includeCode?: boolean;
@@ -10,6 +11,9 @@ export type BuildRegistryOptions = {
  * Published builds include per-function compiled `code`; overlay omits it.
  */
 export declare function toFunctionRegistry(functions: FuncMap, options?: BuildRegistryOptions): Promise<FunctionRegistry>;
-/** Compile optional caseContextView to registry entry. */
-export declare function toCaseContextViewRegistry(view: unknown, options?: BuildRegistryOptions): Promise<CaseContextViewRegistryEntry | null>;
+/**
+ * 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.
+ */
+export declare function toEventRegistry(events: AnyEventHandlers, options?: BuildRegistryOptions): Promise<FunctionRegistry>;
 //# sourceMappingURL=registry.d.ts.map