@superpanel-sdk/runtime 0.2.3 → 0.7.0

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) {
@@ -14,37 +19,35 @@ function isFuncMap(value) {
     if (value == null || typeof value !== 'object' || Array.isArray(value)) {
         return false;
     }
-    for (const entry of Object.values(value)) {
-        if (entry == null || typeof entry !== 'object' || Array.isArray(entry)) {
-            return false;
+    for (const [name, entry] of Object.entries(value)) {
+        if (typeof entry === 'function')
+            continue;
+        // A `defineCaseFunc(…)` / `defineNoCaseFunc(…)` result: functions are plain `(ctx, args)` now (38 §2.1).
+        if (entry != null && typeof entry === 'object' && 'main' in entry) {
+            throw new Error(`functions.${name}: write it as a plain function (ctx, args), its parameters its args type (docs 38; AGENTS.md, "Functions")`);
         }
-        const kind = entry.kind;
-        if (kind !== 'compute' && kind !== 'boolCompute' && kind !== 'custom' && kind !== 'system') {
+        return false;
+    }
+    return true;
+}
+function isEventHandlers(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    for (const [name, handler] of Object.entries(value)) {
+        if (!isSystemEventName(name) || typeof handler !== 'function')
             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))
-        return false;
-    const entries = Object.values(value);
-    return entries.length > 0 && entries.every(looksLikeTable);
-}
-function isSequenceSlots(value) {
-    return isPlainObject(value) && Object.values(value).every(looksLikeTable);
-}
 /**
  * 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 +70,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 +90,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 +98,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 +224,137 @@ 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);
-    }
-    return false;
+/**
+ * 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) {
+    return loadPageModule(pageCode, sequenceId).channels;
 }
 /**
- * Load optional sequence agendas from agendas.ts / agendas/index.ts.
- * Missing module → null (compile produces an empty agendas map).
+ * What the compiled page code says of itself as it loads: its channels, and the page actions it
+ * registered (76 §2.11), read in a context of its own as `loadPageChannels` does.
  */
-export async function loadSequenceAgendas(agendasPath) {
-    const mod = await importModule(agendasPath);
-    if (Object.hasOwn(mod, 'agendas') && isAgendasExport(mod.agendas)) {
-        return mod.agendas;
+export function loadPageModule(pageCode, sequenceId) {
+    try {
+        const entry = runInNewContext(pageCode);
+        const out = entry({ mode: 'channels' });
+        // Copied out of the other context: its arrays are not this one's.
+        return { channels: [...(out.channels ?? [])].map(String), actions: [...(out.actions ?? [])].map(String) };
     }
-    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;
-        }
+    catch (error) {
+        throw new Error(`sequences/${sequenceId}/context.page.ts: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/** The Case Orchestrator from orchestrator.ts / orchestrator/index.ts: `orchestrator`, or the default export. */
+export async function loadSequenceCaseOrchestrator(caseOrchestratorPath) {
+    const mod = await importModule(caseOrchestratorPath);
+    const orchestrator = [mod[ORCHESTRATOR_FUNCTION], mod.default].find((value) => typeof value === 'function');
+    if (!orchestrator) {
+        throw new Error(`Could not find ${ORCHESTRATOR_FUNCTION} export (${ORCHESTRATOR_FUNCTION} | default) as a function in ${caseOrchestratorPath}`);
+    }
+    // Whom a Run may contact is the Orchestrator's to read now (38 §2.8).
+    if (Object.hasOwn(mod, 'contacts')) {
+        throw new Error(`${caseOrchestratorPath}: contacts is no longer supported: delete it. The orchestrator reads whom to contact from the business data, and names them on an Agent request (contacts: [...])`);
     }
-    throw new Error(`Could not find agendas export (agendas | default) in ${agendasPath}`);
+    return orchestrator;
+}
+/** 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`: `(ctx, conversation)`. */
+export async function loadSequenceResolver(resolvePath) {
+    return (await loadResolveExport(resolvePath));
+}
+/** The company `resolve` (§18.2), a function of the company part (22 §5): `(ctx, conversation)`. */
+export async function loadCompanyResolver(resolvePath) {
+    return (await loadResolveExport(resolvePath));
+}
+/** The module of the company's webhooks (22 §9) at the repository root. */
+export const WEBHOOK_MODULE = 'webhook';
+/** `received` of `webhook.ts`, a function of the company part: `(ctx, { event })`. */
+export async function loadCompanyWebhook(webhookPath) {
+    const mod = await importModule(webhookPath);
+    const entry = [mod.received, mod.default].find((value) => typeof value === 'function');
+    if (!entry)
+        throw new Error(`Could not find received export (received | default) as a function in ${webhookPath}`);
+    return 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

@@ -1,10 +1,18 @@
 /**
- * A TS module may live as `<dir>/<name>.ts` or `<dir>/<name>/index.ts`.
+ * A TS module may live as `<dir>/<name>.ts` or `<dir>/<name>/index.ts`, or `.tsx` (a page in JSX, 31 §10).
  * File form is preferred when both exist.
  */
 export declare function tsModuleCandidates(dir: string, name: string): string[];
+/**
+ * A sequence's page script (15 §10.2): `context.page.ts`, written with functions (76). A page in JSX
+ * (`context.page.tsx`, 31) is no longer one.
+ */
+export declare function requirePagePath(sequenceDir: string, sequenceId: string): string;
 /** Return the first existing candidate, or `undefined` if none exist. */
 export declare function findTsModule(dir: string, name: string): string | undefined;
 /** Return the first existing candidate, or throw with `missingMessage`. */
 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,11 +1,26 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
+import { RESOLVE_FUNCTION, RESOLVE_MODULE } from '../core/party/types.js';
 /**
- * A TS module may live as `<dir>/<name>.ts` or `<dir>/<name>/index.ts`.
+ * A TS module may live as `<dir>/<name>.ts` or `<dir>/<name>/index.ts`, or `.tsx` (a page in JSX, 31 §10).
  * File form is preferred when both exist.
  */
 export function tsModuleCandidates(dir, name) {
-    return [path.join(dir, `${name}.ts`), path.join(dir, name, 'index.ts')];
+    return [path.join(dir, `${name}.ts`), path.join(dir, `${name}.tsx`), path.join(dir, name, 'index.ts'), path.join(dir, name, 'index.tsx')];
+}
+/**
+ * A sequence's page script (15 §10.2): `context.page.ts`, written with functions (76). A page in JSX
+ * (`context.page.tsx`, 31) is no longer one.
+ */
+export function requirePagePath(sequenceDir, sequenceId) {
+    const jsx = path.join(sequenceDir, 'context.page.tsx');
+    if (existsSync(jsx)) {
+        throw new Error(`sequences/${sequenceId}/context.page.tsx: a page is written with functions in context.page.ts (76), not JSX: page({ guide }, { name: block({ title }, { … }) }), button({ title, does, action: run(fn.x, { … }) })`);
+    }
+    const page = path.join(sequenceDir, 'context.page.ts');
+    if (!existsSync(page))
+        throw new Error(`sequences/${sequenceId}: context.page.ts is required (the conversation's page, 15 §10.2)`);
+    return page;
 }
 /** Return the first existing candidate, or `undefined` if none exist. */
 export function findTsModule(dir, name) {
@@ -19,4 +34,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,25 @@
+import { type ScheduleDefinition, type ScheduleManifest } from '../core/functions/schedules.js';
+import type { FuncMap, FunctionRegistry } from '../core/functions/types.js';
+import type { FunctionSourceMap } from './types.js';
+/**
+ * Why one job's `cron` / `timezone` cannot run, or `null`. The cron is read by the same parser the
+ * worker's job scheduler uses (BullMQ's cron-parser); five fields only, so nothing runs every second.
+ */
+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`, a function `(ctx, { schedule })`. */
+    functions: FuncMap;
+    manifest: ScheduleManifest;
+};
+/** Load and check the repository root's `schedules.ts`, the company's only one (25 §6.4). */
+export declare function loadSchedules(repoRoot: string): Promise<LoadedSchedules | null>;
+/**
+ * The build's registry entries of the jobs: `schedule.<name>` (`code` left out on the serve overlay). Each
+ * compiled job's source map goes to `sourceMaps`, by the same name.
+ */
+export declare function scheduleRegistry(loaded: LoadedSchedules, includeCode: boolean, sourceMaps?: Record<string, FunctionSourceMap>): Promise<FunctionRegistry>;
+//# sourceMappingURL=schedules.d.ts.map

package/dist/builder/schedules.js

@@ -0,0 +1,101 @@
+import { pathToFileURL } from 'node:url';
+import { CronExpressionParser } from 'cron-parser';
+import { SCHEDULES_MODULE, scheduleFunctionName, } from '../core/functions/schedules.js';
+import { compileScheduleModuleCode } from './compile/function-code.js';
+import { companyImportGraphHref } from './company-import-graph.js';
+import { findTsModule } from './paths.js';
+/** A job name: an identifier, so `schedule.<name>` stays one plain function name. */
+const SCHEDULE_NAME = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
+function isPlainObject(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+/** Whether `timezone` is an IANA name this runtime knows. */
+function knownTimezone(timezone) {
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: timezone });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 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 function scheduleTimingIssue(cron, timezone) {
+    if (typeof timezone !== 'string' || !knownTimezone(timezone)) {
+        return `timezone ${JSON.stringify(timezone)} is not an IANA timezone (e.g. 'UTC', 'America/Phoenix')`;
+    }
+    if (typeof cron !== 'string' || cron.trim().split(/\s+/).length !== 5) {
+        return `cron ${JSON.stringify(cron)} must have five fields: minute hour day-of-month month day-of-week (e.g. '0 2 * * *')`;
+    }
+    try {
+        CronExpressionParser.parse(cron.trim(), { tz: timezone }).next();
+    }
+    catch (error) {
+        return `cron ${JSON.stringify(cron)} is not valid: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    return null;
+}
+/** Read a `schedules` export: every job named, timed and runnable, else one error listing what is wrong. */
+export function parseSchedules(value, where) {
+    if (!isPlainObject(value)) {
+        throw new Error(`${where}: export const schedules = defineSchedules({ name: { cron, timezone, run } })`);
+    }
+    const issues = [];
+    for (const [name, entry] of Object.entries(value)) {
+        if (!SCHEDULE_NAME.test(name)) {
+            issues.push(`'${name}': a job name is letters, digits and _ starting with a letter (at most 64)`);
+            continue;
+        }
+        if (!isPlainObject(entry)) {
+            issues.push(`'${name}': expected { cron, timezone, run }`);
+            continue;
+        }
+        if (typeof entry.run !== 'function')
+            issues.push(`'${name}': run must be an async function (ctx) => { … }`);
+        const timing = scheduleTimingIssue(entry.cron, entry.timezone);
+        if (timing)
+            issues.push(`'${name}': ${timing}`);
+    }
+    if (issues.length > 0)
+        throw new Error(`${where}: ${issues.join('; ')} (25 §6.4)`);
+    return value;
+}
+async function importSchedules(modulePath, where) {
+    const mod = (await import(companyImportGraphHref(pathToFileURL(modulePath).href)));
+    const fromDefault = isPlainObject(mod.default) && Object.hasOwn(mod.default, 'schedules') ? mod.default.schedules : mod.default;
+    return parseSchedules(mod.schedules ?? fromDefault, where);
+}
+/** Load and check the repository root's `schedules.ts`, the company's only one (25 §6.4). */
+export async function loadSchedules(repoRoot) {
+    const modulePath = findTsModule(repoRoot, SCHEDULES_MODULE);
+    if (!modulePath)
+        return null;
+    const schedules = await importSchedules(modulePath, `${SCHEDULES_MODULE}.ts`);
+    const functions = {};
+    const manifest = {};
+    for (const [name, { cron, timezone, run }] of Object.entries(schedules)) {
+        functions[scheduleFunctionName(name)] = run;
+        manifest[name] = { cron: cron.trim(), timezone };
+    }
+    return { path: modulePath, functions, manifest };
+}
+/**
+ * The build's registry entries of the jobs: `schedule.<name>` (`code` left out on the serve overlay). Each
+ * compiled job's source map goes to `sourceMaps`, by the same name.
+ */
+export async function scheduleRegistry(loaded, includeCode, sourceMaps) {
+    const entries = await Promise.all(Object.keys(loaded.manifest).map(async (name) => {
+        const fn = scheduleFunctionName(name);
+        if (!includeCode)
+            return [fn, {}];
+        const compiled = await compileScheduleModuleCode(loaded.path, name);
+        if (sourceMaps)
+            sourceMaps[fn] = compiled.map;
+        return [fn, { code: compiled.code }];
+    }));
+    return Object.fromEntries(entries);
+}
+//# sourceMappingURL=schedules.js.map

package/dist/builder/slot-schema-validation.d.ts

@@ -0,0 +1,4 @@
+import type { ValidationIssue } from '../core/slot/types.js';
+/** The issues that stop codegen and compile: all but {@link WARNING_SLOT_SCHEMA_CODES}. */
+export declare function fatalSlotSchemaIssues(issues: ValidationIssue[]): ValidationIssue[];
+//# sourceMappingURL=slot-schema-validation.d.ts.map

package/dist/builder/slot-schema-validation.js

@@ -0,0 +1,10 @@
+/**
+ * Slot schema issues that only warn. Every other issue fails codegen and compile: a new issue code
+ * blocks the build unless it is listed here on purpose. None warns today.
+ */
+const WARNING_SLOT_SCHEMA_CODES = new Set([]);
+/** The issues that stop codegen and compile: all but {@link WARNING_SLOT_SCHEMA_CODES}. */
+export function fatalSlotSchemaIssues(issues) {
+    return issues.filter((issue) => !WARNING_SLOT_SCHEMA_CODES.has(issue.code));
+}
+//# sourceMappingURL=slot-schema-validation.js.map

package/dist/builder/typecheck.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The repository's type check, as `npm run typecheck` runs it locally: `type:gen`, then `tsc --noEmit`
+ * with the repo's own `tsconfig.json`. With no sequence it writes only the root `__gen` (the local
+ * `type:gen` needs a sequence). The compile runs it itself, so a type error blocks a release in every
+ * environment; the platform never calls the repo's `typecheck` script.
+ */
+export declare function typecheckRepo(repoRoot: string, onLog?: (text: string) => void): Promise<void>;
+//# sourceMappingURL=typecheck.d.ts.map