@superpanel-sdk/runtime 0.2.2 → 0.5.0

package/dist/builder/compile/registry.js

@@ -1,5 +1,5 @@
-import { resolveCaseContextViewFn } from '../../core/functions/define/case-context.js';
-import { compileCaseContextViewModuleCode, compileFunctionCode, compileFunctionModuleCode, } from './function-code.js';
+import { isSystemEventName, systemEventKind } from '../../core/functions/events.js';
+import { compileEventModuleCode, compileFunctionCode, compileFunctionModuleCode } from './function-code.js';
 function withCode(entry, code) {
     if (code === undefined)
         return entry;
@@ -18,31 +18,32 @@ export async function toFunctionRegistry(functions, options = {}) {
                 ? await compileFunctionModuleCode(options.modulePath, name)
                 : await compileFunctionCode(def.main)
             : undefined;
-        let entry;
-        if (def.kind === 'custom') {
-            entry = withCode({ kind: 'custom', writes: [] }, code);
-        }
-        else if (def.kind === 'system') {
-            entry = withCode({ kind: 'system' }, code);
-        }
-        else {
-            entry = withCode({ kind: def.kind }, code);
-        }
+        const entry = withCode({ kind: def.kind }, code);
         out[name] = entry;
     }
     return out;
 }
-/** Compile optional caseContextView to registry entry. */
-export async function toCaseContextViewRegistry(view, options = {}) {
-    const fn = resolveCaseContextViewFn(view);
-    if (!fn)
-        return null;
-    if (!(options.includeCode ?? true)) {
-        return { kind: 'caseContextView' };
+/**
+ * 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 async function toEventRegistry(events, options = {}) {
+    const includeCode = options.includeCode ?? true;
+    const out = {};
+    for (const [name, handler] of Object.entries(events)) {
+        if (!isSystemEventName(name)) {
+            throw new Error(`events: '${name}' is not a platform event`);
+        }
+        if (typeof handler !== 'function') {
+            throw new Error(`events: handler for '${name}' must be a function`);
+        }
+        const code = includeCode
+            ? options.modulePath
+                ? await compileEventModuleCode(options.modulePath, name)
+                : await compileFunctionCode(handler)
+            : undefined;
+        out[name] = withCode({ kind: systemEventKind(name) }, code);
     }
-    const code = options.modulePath
-        ? await compileCaseContextViewModuleCode(options.modulePath)
-        : await compileFunctionCode(fn);
-    return { kind: 'caseContextView', code };
+    return out;
 }
 //# sourceMappingURL=registry.js.map

package/dist/builder/load.d.ts

@@ -1,22 +1,82 @@
-import { type CaseContextViewFn } from '../core/functions/define/case-context.js';
-import type { FuncMap } from '../core/functions/types.js';
-import type { CompanySchema, SequenceSlots } from '../core/slot/schema.js';
-/** Sequence ids that have a slots.ts / slots/index.ts module. */
+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 OfficeHours } from '../core/office-hours/index.js';
+import { type CompanySchema, type SessionSchema } from '../core/slot/schema.js';
+/**
+ * A sequence's leftover `slots.ts` (or `slots/index.ts`): the sequence layer has no schema any more
+ * (15 §10.17 第 1 条). Its tables and fields are the company's; how a cell is filled is the page's
+ * `$extraction`.
+ */
+export declare function assertNoSlotsModule(sequenceDir: string, sequenceId: string): void;
+/** Sequence ids: the directories under `sequences/` with an `index.ts` (`defineSequence`). */
 export declare function listSequenceIds(repoRoot: string): string[];
 export declare function loadCompanySchema(schemaPath: string): Promise<CompanySchema>;
-export declare function loadSequenceSlots(slotsPath: string): Promise<SequenceSlots>;
+/**
+ * The company's session fields from `schema/session.ts` (or `schema/session/index.ts`), its
+ * `sessionSchema` export (11-remove-sequence-schema §3.1). No file: sessions have no fields.
+ */
+export declare function loadSessionSchema(repoRoot: string): Promise<SessionSchema>;
+/**
+ * Sequence office hours from `sequences/<id>/office-hours.ts`. Missing file is `null` (always open).
+ * A present file that does not export a valid `officeHours` fails compile.
+ */
+export declare function loadOfficeHours(sequenceDir: string): Promise<OfficeHours | null>;
 /**
  * Load sequence `functions` map from functions.ts or functions/index.ts.
  * Accepts named `functions` or default export FuncMap.
  */
 export declare function loadSequenceFunctions(functionsPath: string): Promise<FuncMap>;
 /**
- * Load optional `caseContextView` from view.ts / view/index.ts.
+ * Load optional sequence `events` map from events.ts / events/index.ts.
+ * Keys must be platform event names; values are plain handler functions.
+ */
+export declare function loadSequenceEvents(eventsPath: string): Promise<AnyEventHandlers>;
+/**
+ * The channels `context.page.ts` has a page function for (17b §9.1). Read from the compiled page code in
+ * a context of its own, as the platform runs it: importing the page module here would register its
+ * actions in this process, and a second compile would find them named twice. `persona` and `faq` are
+ * called when a conversation starts (24 §4), not here.
+ */
+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).
+ */
+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>>;
+/** 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>>;
+export declare function isPlatformName(name: string): boolean;
+/**
+ * A leftover root `channels.ts` (or `channels/index.ts`): webhook URLs are made and named on the
+ * Webhooks page now, like phone numbers, and code refers to them by name only.
+ */
+export declare function assertNoChannelsModule(repoRoot: string): void;
+/**
+ * `sequences/<id>/index.ts` default export (`defineSequence({ subject })`): the sequence's business
+ * root. Without the file or the declaration, `subject` is undefined and the compile reports it.
  */
-export declare function loadSequenceCaseContextView(viewPath: string): Promise<CaseContextViewFn>;
+export declare function loadSequenceDefinition(sequenceDir: string): Promise<{
+    subject: unknown;
+    label: unknown;
+}>;
 /**
- * Load optional sequence agendas from agendas.ts / agendas/index.ts.
- * Missing module → null (compile produces an empty agendas map).
+ * `sequences/<id>/variables.ts` (14-sequence-instance §4.4): `variables` (from `defineVariables`) and
+ * the optional `experiments`. Both undefined without the file.
  */
-export declare function loadSequenceAgendas(agendasPath: string): Promise<unknown>;
+export declare function loadSequenceVariables(sequenceDir: string): Promise<{
+    variables: unknown;
+    experiments: unknown;
+}>;
 //# sourceMappingURL=load.d.ts.map

package/dist/builder/load.js

@@ -1,8 +1,13 @@
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { resolveCaseContextViewFn } from '../core/functions/define/case-context.js';
-import { isAgendaTree, isSequenceAgendas } from '../core/stage/flatten.js';
+import { runInNewContext } from 'node:vm';
+import { ORCHESTRATOR_FUNCTION } from '../core/case-orchestrator/types.js';
+import { RESOLVE_FUNCTION } from '../core/party/types.js';
+import { isSystemEventName, } from '../core/functions/events.js';
+import { parseOfficeHours } from '../core/office-hours/index.js';
+import { sessionSchemaIssues } from '../core/slot/company-metadata.js';
+import { companySchemaSchema, EMPTY_SESSION_SCHEMA, isCompanySchema, REMOVED_DERIVED_KEYS, REMOVED_IDENTIFIER_KEY, REMOVED_NULLABLE_KEY, REMOVED_SOURCE_KEY, } from '../core/slot/schema.js';
 import { companyImportGraphHref } from './company-import-graph.js';
 import { findTsModule } from './paths.js';
 async function importModule(filePath) {
@@ -19,32 +24,34 @@ function isFuncMap(value) {
             return false;
         }
         const kind = entry.kind;
-        if (kind !== 'compute' && kind !== 'boolCompute' && kind !== 'custom' && kind !== 'system') {
+        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;
         }
     }
     return true;
 }
-function isPlainObject(value) {
-    return value != null && typeof value === 'object' && !Array.isArray(value);
-}
-function looksLikeTable(value) {
-    return isPlainObject(value) && isPlainObject(value.fields);
-}
-function isCompanySchema(value) {
-    if (!isPlainObject(value))
+function isEventHandlers(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
         return false;
-    const entries = Object.values(value);
-    return entries.length > 0 && entries.every(looksLikeTable);
+    }
+    for (const [name, handler] of Object.entries(value)) {
+        if (!isSystemEventName(name) || typeof handler !== 'function')
+            return false;
+    }
+    return true;
 }
-function isSequenceSlots(value) {
-    return isPlainObject(value) && Object.values(value).every(looksLikeTable);
+function isPlainObject(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
 }
 /**
  * Resolve the config object from a dynamically imported module.
  *
  * Accepted authoring styles (first match wins):
- * 1. Named export — `export const slots = { session, … }`
+ * 1. Named export — `export const companySchema = { … }`
  * 2. Default export is the config
  * 3. Default export is a bag that holds a named key
  */
@@ -67,7 +74,17 @@ function pickExport(mod, names, label, isConfig) {
     }
     throw new Error(`Could not find ${label} export (${names.join(' | ')}) in module`);
 }
-/** Sequence ids that have a slots.ts / slots/index.ts module. */
+/**
+ * A sequence's leftover `slots.ts` (or `slots/index.ts`): the sequence layer has no schema any more
+ * (15 §10.17 第 1 条). Its tables and fields are the company's; how a cell is filled is the page's
+ * `$extraction`.
+ */
+export function assertNoSlotsModule(sequenceDir, sequenceId) {
+    if (findTsModule(sequenceDir, 'slots') === undefined)
+        return;
+    throw new Error(`sequences/${sequenceId}/slots.ts is no longer supported (slots-removed): delete it. Every sequence reads all of the company schema; write how to fill a field on the page in its $extraction, and session fields in schema/session.ts`);
+}
+/** Sequence ids: the directories under `sequences/` with an `index.ts` (`defineSequence`). */
 export function listSequenceIds(repoRoot) {
     const sequencesDir = path.join(repoRoot, 'sequences');
     if (!existsSync(sequencesDir)) {
@@ -77,7 +94,7 @@ export function listSequenceIds(repoRoot) {
         .filter((name) => {
         try {
             return (statSync(path.join(sequencesDir, name)).isDirectory() &&
-                findTsModule(path.join(sequencesDir, name), 'slots') !== undefined);
+                findTsModule(path.join(sequencesDir, name), 'index') !== undefined);
         }
         catch {
             return false;
@@ -85,13 +102,109 @@ export function listSequenceIds(repoRoot) {
     })
         .sort();
 }
+/**
+ * Leftover removed keys, as `table.field: remove …`: derived fields (13-data-model-v1 §21) and
+ * `source` (19-page-writable-cells).
+ */
+function leftoverDerivedKeys(value) {
+    const leftovers = [];
+    if (!isPlainObject(value))
+        return leftovers;
+    for (const [tableName, table] of Object.entries(value)) {
+        const fields = isPlainObject(table) && isPlainObject(table.fields) ? table.fields : {};
+        for (const [fieldName, field] of Object.entries(fields)) {
+            const keys = isPlainObject(field) ? REMOVED_DERIVED_KEYS.filter((key) => Object.hasOwn(field, key)) : [];
+            if (keys.length > 0) {
+                leftovers.push(`${tableName}.${fieldName}: remove ${keys.join(', ')} (derived fields were removed)`);
+            }
+            if (isPlainObject(field) && Object.hasOwn(field, REMOVED_SOURCE_KEY)) {
+                leftovers.push(`${tableName}.${fieldName}: remove source (source-removed: a page decides what the AI may write; field(...) opens a cell)`);
+            }
+            if (isPlainObject(field) && Object.hasOwn(field, REMOVED_NULLABLE_KEY)) {
+                leftovers.push(`${tableName}.${fieldName}: remove nullable (nullable-removed: every field starts empty and can be cleared; a page's required says when one must be filled)`);
+            }
+            if (isPlainObject(field) && Object.hasOwn(field, REMOVED_IDENTIFIER_KEY)) {
+                leftovers.push(`${tableName}.${fieldName}: remove identifier (identifier-removed: resolve.ts decides who a conversation is with)`);
+            }
+        }
+    }
+    return leftovers;
+}
+const COMPANY_SCHEMA_EXPORTS = ['companySchema', 'schema'];
+/**
+ * Everything the module may offer as its company schema, in {@link pickExport}'s order: the named
+ * exports, the default export's named keys, then the default export itself.
+ */
+function companySchemaCandidates(mod) {
+    const candidates = COMPANY_SCHEMA_EXPORTS.map((name) => mod[name]);
+    const defaultExport = Object.hasOwn(mod, 'default') ? mod.default : undefined;
+    if (isPlainObject(defaultExport))
+        candidates.push(...COMPANY_SCHEMA_EXPORTS.map((name) => defaultExport[name]));
+    candidates.push(defaultExport);
+    return candidates.filter((candidate) => candidate !== undefined);
+}
+/**
+ * Why none of the candidates parses: the leftover derived keys of the first candidate that has any
+ * (a default-exported schema with a table named `schema` is a candidate both as a whole and as that
+ * table, so taking the first candidate alone could pick the table), otherwise the first candidate's
+ * first Zod issues.
+ */
+function companySchemaProblems(candidates) {
+    for (const candidate of candidates) {
+        const leftovers = leftoverDerivedKeys(candidate);
+        if (leftovers.length > 0)
+            return leftovers;
+    }
+    const issues = companySchemaSchema.safeParse(candidates[0]).error?.issues ?? [];
+    return issues.slice(0, 5).map((issue) => `${issue.path.join('.') || '(root)'}: ${issue.message}`);
+}
 export async function loadCompanySchema(schemaPath) {
     const mod = await importModule(schemaPath);
-    return pickExport(mod, ['companySchema', 'schema'], 'company schema', isCompanySchema);
+    try {
+        return pickExport(mod, COMPANY_SCHEMA_EXPORTS, 'company schema', isCompanySchema);
+    }
+    catch (error) {
+        // Say what is wrong with the schema it does export, in whichever supported form.
+        const candidates = companySchemaCandidates(mod);
+        if (candidates.length === 0)
+            throw error;
+        throw new Error(`Invalid company schema in ${schemaPath}: ${companySchemaProblems(candidates).join('; ')}`);
+    }
+}
+/**
+ * The company's session fields from `schema/session.ts` (or `schema/session/index.ts`), its
+ * `sessionSchema` export (11-remove-sequence-schema §3.1). No file: sessions have no fields.
+ */
+export async function loadSessionSchema(repoRoot) {
+    const filePath = findTsModule(path.join(repoRoot, 'schema'), 'session');
+    if (!filePath)
+        return EMPTY_SESSION_SCHEMA;
+    const mod = await importModule(filePath);
+    if (!Object.hasOwn(mod, 'sessionSchema')) {
+        throw new Error(`Could not find sessionSchema export in ${filePath}`);
+    }
+    const issues = sessionSchemaIssues(mod.sessionSchema);
+    if (issues.length > 0)
+        throw new Error(issues.map((issue) => issue.message).join('; '));
+    return mod.sessionSchema;
 }
-export async function loadSequenceSlots(slotsPath) {
-    const mod = await importModule(slotsPath);
-    return pickExport(mod, ['slots'], 'sequence slots', isSequenceSlots);
+/**
+ * Sequence office hours from `sequences/<id>/office-hours.ts`. Missing file is `null` (always open).
+ * A present file that does not export a valid `officeHours` fails compile.
+ */
+export async function loadOfficeHours(sequenceDir) {
+    const filePath = findTsModule(sequenceDir, 'office-hours');
+    if (!filePath)
+        return null;
+    const mod = await importModule(filePath);
+    if (!Object.hasOwn(mod, 'officeHours')) {
+        throw new Error(`Could not find officeHours export in ${filePath}`);
+    }
+    const parsed = parseOfficeHours(mod.officeHours);
+    if (!parsed.ok) {
+        throw new Error(`office-hours.ts: ${parsed.issues.join('; ')}`);
+    }
+    return parsed.value;
 }
 /**
  * Load sequence `functions` map from functions.ts or functions/index.ts.
@@ -115,55 +228,131 @@ export async function loadSequenceFunctions(functionsPath) {
     throw new Error(`Could not find functions export (functions | default) as a FuncMap in ${functionsPath}`);
 }
 /**
- * Load optional `caseContextView` from view.ts / view/index.ts.
+ * Load optional sequence `events` map from events.ts / events/index.ts.
+ * Keys must be platform event names; values are plain handler functions.
  */
-export async function loadSequenceCaseContextView(viewPath) {
-    const mod = await importModule(viewPath);
-    const fromNamed = resolveCaseContextViewFn(mod.caseContextView);
-    if (fromNamed)
-        return fromNamed;
+export async function loadSequenceEvents(eventsPath) {
+    const mod = await importModule(eventsPath);
+    for (const handlers of [mod.events, mod.default, mod.default?.events]) {
+        if (isPlainObject(handlers) && Object.hasOwn(handlers, 'webhook.received')) {
+            throw new Error(`${eventsPath}: webhook.received is no longer a sequence event; export received from ${WEBHOOK_MODULE}.ts at the repository root (22 §9)`);
+        }
+    }
+    if (Object.hasOwn(mod, 'events')) {
+        if (isEventHandlers(mod.events))
+            return mod.events;
+        throw new Error(`events export in ${eventsPath} has unknown event names or non-function handlers`);
+    }
     const defaultExport = Object.hasOwn(mod, 'default') ? mod.default : undefined;
-    const fromDefault = resolveCaseContextViewFn(defaultExport);
-    if (fromDefault)
-        return fromDefault;
+    if (isEventHandlers(defaultExport)) {
+        return defaultExport;
+    }
     if (defaultExport != null && typeof defaultExport === 'object' && !Array.isArray(defaultExport)) {
-        const fromBag = resolveCaseContextViewFn(defaultExport.caseContextView);
-        if (fromBag)
-            return fromBag;
+        const bag = defaultExport;
+        if (Object.hasOwn(bag, 'events') && isEventHandlers(bag.events)) {
+            return bag.events;
+        }
     }
-    throw new Error(`Could not find caseContextView export (caseContextView | default) as a function in ${viewPath}`);
+    throw new Error(`Could not find events export (events | default) as an EventHandlers map in ${eventsPath}`);
 }
-function isAgendasExport(value) {
-    if (value == null)
-        return false;
-    if (isSequenceAgendas(value) || isAgendaTree(value))
-        return true;
-    if (Array.isArray(value) && value.length > 0 && value.every(isAgendaTree))
-        return true;
-    if (typeof value === 'object' && !Array.isArray(value)) {
-        const values = Object.values(value);
-        return values.length > 0 && values.every(isAgendaTree);
+/**
+ * The channels `context.page.ts` has a page function for (17b §9.1). Read from the compiled page code in
+ * a context of its own, as the platform runs it: importing the page module here would register its
+ * actions in this process, and a second compile would find them named twice. `persona` and `faq` are
+ * called when a conversation starts (24 §4), not here.
+ */
+export function loadPageChannels(pageCode, sequenceId) {
+    try {
+        const entry = runInNewContext(pageCode);
+        // Copied out of the other context: its arrays are not this one's.
+        return [...(entry({ mode: 'channels' }).channels ?? [])].map(String);
+    }
+    catch (error) {
+        throw new Error(`sequences/${sequenceId}/context.page.ts: ${error instanceof Error ? error.message : String(error)}`);
     }
-    return false;
 }
 /**
- * Load optional sequence agendas from agendas.ts / agendas/index.ts.
- * Missing module → null (compile produces an empty agendas map).
+ * 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).
  */
-export async function loadSequenceAgendas(agendasPath) {
-    const mod = await importModule(agendasPath);
-    if (Object.hasOwn(mod, 'agendas') && isAgendasExport(mod.agendas)) {
-        return mod.agendas;
+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}`);
     }
-    const defaultExport = Object.hasOwn(mod, 'default') ? mod.default : undefined;
-    if (isAgendasExport(defaultExport))
-        return defaultExport;
-    if (defaultExport != null && typeof defaultExport === 'object' && !Array.isArray(defaultExport)) {
-        const bag = defaultExport;
-        if (Object.hasOwn(bag, 'agendas') && isAgendasExport(bag.agendas)) {
-            return bag.agendas;
-        }
+    if (typeof mod.contacts !== 'function') {
+        throw new Error(`${caseOrchestratorPath}: export contacts, whom a Run may contact: export const contacts: CaseOrchestratorContacts = async (c, ctx) => contactIds`);
     }
-    throw new Error(`Could not find agendas export (agendas | default) in ${agendasPath}`);
+    return { orchestrator: orchestrator, contacts: mod.contacts };
+}
+/** A `resolve.ts` / `resolve/index.ts`: its exported function `resolve` (or the default export). */
+async function loadResolveExport(resolvePath) {
+    const mod = await importModule(resolvePath);
+    const entry = [mod[RESOLVE_FUNCTION], mod.default].find((value) => typeof value === 'function');
+    if (entry)
+        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. */
+export async function loadSequenceResolver(resolvePath) {
+    return { kind: 'noCase', main: (await loadResolveExport(resolvePath)) };
+}
+/** The company `resolve` (§18.2), registered as a `noCase` function of the company part (22 §5). */
+export async function loadCompanyResolver(resolvePath) {
+    return { kind: 'noCase', main: (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. */
+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 };
+}
+/** 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]+)*$/;
+const PLATFORM_NAME_MAX = 40;
+export function isPlatformName(name) {
+    return name.length <= PLATFORM_NAME_MAX && PLATFORM_NAME.test(name);
+}
+/**
+ * A leftover root `channels.ts` (or `channels/index.ts`): webhook URLs are made and named on the
+ * Webhooks page now, like phone numbers, and code refers to them by name only.
+ */
+export function assertNoChannelsModule(repoRoot) {
+    if (!findTsModule(repoRoot, 'channels'))
+        return;
+    throw new Error(`channels.ts is no longer supported (channels-removed): delete it. Make webhook URLs on the Webhooks page of each environment and tell them apart in ${WEBHOOK_MODULE}.ts by webhook.name`);
+}
+/**
+ * `sequences/<id>/index.ts` default export (`defineSequence({ subject })`): the sequence's business
+ * root. Without the file or the declaration, `subject` is undefined and the compile reports it.
+ */
+export async function loadSequenceDefinition(sequenceDir) {
+    const indexPath = findTsModule(sequenceDir, 'index');
+    if (!indexPath)
+        return { subject: undefined, label: undefined };
+    const mod = await importModule(indexPath);
+    const definition = isPlainObject(mod.default) ? mod.default : isPlainObject(mod.sequence) ? mod.sequence : {};
+    const { subject, meta } = definition;
+    return { subject, label: isPlainObject(meta) ? meta.label : undefined };
+}
+/**
+ * `sequences/<id>/variables.ts` (14-sequence-instance §4.4): `variables` (from `defineVariables`) and
+ * the optional `experiments`. Both undefined without the file.
+ */
+export async function loadSequenceVariables(sequenceDir) {
+    const variablesPath = findTsModule(sequenceDir, 'variables');
+    if (!variablesPath)
+        return { variables: undefined, experiments: undefined };
+    const mod = await importModule(variablesPath);
+    const bag = isPlainObject(mod.default) ? mod.default : {};
+    return {
+        variables: mod.variables ?? bag.variables,
+        experiments: mod.experiments ?? bag.experiments,
+    };
 }
 //# sourceMappingURL=load.js.map

package/dist/builder/paths.d.ts

@@ -7,4 +7,7 @@ export declare function tsModuleCandidates(dir: string, name: string): string[];
 export declare function findTsModule(dir: string, name: string): string | undefined;
 /** Return the first existing candidate, or throw with `missingMessage`. */
 export declare function resolveTsModule(dir: string, name: string, missingMessage: string): string;
+export declare function requireResolveModule(sequenceDir: string, sequenceId: string): string;
+/** The company `resolve.ts` at the repo root (14-sequence-instance §18.2): required. */
+export declare function requireCompanyResolveModule(repoRoot: string): string;
 //# sourceMappingURL=paths.d.ts.map

package/dist/builder/paths.js

@@ -1,5 +1,6 @@
 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`.
  * File form is preferred when both exist.
@@ -19,4 +20,19 @@ export function resolveTsModule(dir, name, missingMessage) {
     }
     return found;
 }
+export function requireResolveModule(sequenceDir, sequenceId) {
+    const resolvePath = findTsModule(sequenceDir, RESOLVE_MODULE);
+    if (!resolvePath) {
+        throw new Error(`sequences/${sequenceId}/${RESOLVE_MODULE}.ts is required: export ${RESOLVE_FUNCTION} from it to decide which contact and instance a conversation opens on`);
+    }
+    return resolvePath;
+}
+/** The company `resolve.ts` at the repo root (14-sequence-instance §18.2): required. */
+export function requireCompanyResolveModule(repoRoot) {
+    const resolvePath = findTsModule(repoRoot, RESOLVE_MODULE);
+    if (!resolvePath) {
+        throw new Error(`${RESOLVE_MODULE}.ts is required at the company repo root: export ${RESOLVE_FUNCTION} from it to decide which sequence an inbound conversation goes to`);
+    }
+    return resolvePath;
+}
 //# sourceMappingURL=paths.js.map

package/dist/builder/schedules.d.ts

@@ -0,0 +1,23 @@
+import { type ScheduleDefinition, type ScheduleManifest } from '../core/functions/schedules.js';
+import type { FuncMap, FunctionRegistry } from '../core/functions/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.
+ */
+export declare function scheduleTimingIssue(cron: unknown, timezone: unknown): string | null;
+/** Read a `schedules` export: every job named, timed and runnable, else one error listing what is wrong. */
+export declare function parseSchedules(value: unknown, where: string): Record<string, ScheduleDefinition>;
+/** 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. */
+    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;
+//# sourceMappingURL=schedules.d.ts.map