@superpanel-sdk/runtime 0.5.0 → 0.7.0

package/dist/core/conversation/index.js

@@ -4,11 +4,130 @@
 /** The channels a conversation runs on. A conversation engine runs on calls and SMS (17b §9.0); email routes and stores only. */
 export const CHANNELS = ['call', 'sms', 'email'];
 /**
- * The languages the platform speaks: the values of the contact's `language` field. Each needs a voice
- * (the default voice profile's settings for it) and the platform's fixed lines in it.
+ * The languages a contact can have (`contact.language`, 48 §3) and texts and emails tag their replies with
+ * (48 §5.2): BCP-47 base tags. Texts and emails need no voice, so they are not limited to what calls can
+ * speak (75 §3); a contact who writes in Chinese keeps `zh`, and a call with them opens in English.
  */
-export const SPOKEN_LANGUAGES = ['english', 'spanish'];
+export const CONTACT_LANGUAGES = [
+    'en', 'fr', 'de', 'es', 'pt', 'zh', 'ja', 'hi', 'it', 'ko', 'nl', 'pl', 'ru', 'sv', 'tr', 'tl', 'bg', 'ro', 'ar', 'cs',
+    'el', 'fi', 'hr', 'ms', 'sk', 'da', 'ta', 'uk', 'hu', 'no', 'vi', 'bn', 'th', 'he', 'ka', 'id', 'te', 'gu', 'kn', 'ml',
+    'mr', 'pa',
+];
+/**
+ * The languages calls can speak (48 §4, narrowed by 75 §3): the platform language table's tags, the ones
+ * Deepgram Flux (`flux-general-multi`) turns on, all spoken by Cartesia. Each has a native default voice,
+ * the platform's fixed lines and STOP words (services' language table). A caller speaking another language
+ * is answered in the call's language, told once it cannot be spoken (48 §1 item 6).
+ */
+export const SPOKEN_LANGUAGES = ['en', 'es', 'fr', 'de', 'hi', 'ru', 'pt', 'ja', 'it', 'nl'];
+/**
+ * `value` checked as a `Spoken` (66 §2): an object, at least one language, every key a table tag, every
+ * text not empty. Copied, in the order written. No `Intl` (the page sandbox has none).
+ */
+export function checkSpoken(value, at) {
+    if (typeof value === 'string')
+        throw new Error(`${at}: write it per language, { en: '…', es: '…' } (66 §2), not one string`);
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new Error(`${at}: write it per language, { en: '…', es: '…' } (66 §2)`);
+    const out = {};
+    for (const [key, text] of Object.entries(value)) {
+        if (!SPOKEN_LANGUAGES.includes(key))
+            throw new Error(`${at}: '${key}' is not a language of the platform's table (${SPOKEN_LANGUAGES.join(', ')})`);
+        if (typeof text !== 'string' || !text.trim())
+            throw new Error(`${at}: the ${key} text is empty`);
+        out[key] = text;
+    }
+    if (!Object.keys(out).length)
+        throw new Error(`${at}: write it in at least one language`);
+    return out;
+}
+/** The text a `Spoken` falls back to (66 §3): `en` when written, else the first language written. */
+export function fallbackSpoken(spoken) {
+    const texts = spoken;
+    if (texts.en)
+        return { text: texts.en, language: 'en' };
+    const [language, text] = Object.entries(texts).find(([, t]) => !!t);
+    return { text, language };
+}
+/**
+ * The line to say on a call in `language` (66 §3): the same tag, else the same base language
+ * (`pt-BR` → `pt`), else `en`, else the first written. `missing`: the language it fell back from, to tell
+ * the company.
+ */
+export function pickSpoken(spoken, language) {
+    const texts = spoken;
+    if (language) {
+        const exact = texts[language];
+        if (exact)
+            return { text: exact, missing: null };
+        const base = matchSpokenLanguage(language);
+        const near = base ? texts[base] : undefined;
+        if (near)
+            return { text: near, missing: null };
+    }
+    const fallback = fallbackSpoken(spoken);
+    return { text: fallback.text, missing: language && language !== fallback.language ? language : null };
+}
+/**
+ * Tags a table entry is not the fallback for (48 §2): the same base language, not understood by its
+ * speakers. Matched by language and region (`zh-HK` covers `zh-Hant-HK`); Cantonese (`yue`) is apart already.
+ */
+const NOT_FALLBACK_FOR = { zh: ['zh-HK', 'zh-MO'] };
+/** `value` as a canonical BCP-47 tag (`pt-br` → `pt-BR`), or null when it is not one. */
+export function canonicalLanguage(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return null;
+    try {
+        return Intl.getCanonicalLocales(value.trim())[0] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Whether `value` is one of the table's tags as stored (a language calls can speak). */
 export function isSpokenLanguage(value) {
-    return typeof value === 'string' && SPOKEN_LANGUAGES.includes(value.trim());
+    return typeof value === 'string' && SPOKEN_LANGUAGES.includes(value);
+}
+/** Whether `value` is a language `contact.language` can hold, as stored (texts and emails: any of them). */
+export function isContactLanguage(value) {
+    return typeof value === 'string' && CONTACT_LANGUAGES.includes(value);
+}
+/**
+ * The table's language a tag resolves to (48 §2): the same tag, else the first with its base language
+ * (`es-MX` → `es`), unless that entry is not the fallback for it (`zh-HK`). Null: calls cannot speak it.
+ */
+export function matchSpokenLanguage(value) {
+    return matchIn(SPOKEN_LANGUAGES, value);
+}
+/** The contact language a tag resolves to, as {@link matchSpokenLanguage} (`zh-CN` → `zh`). Null: none. */
+export function matchContactLanguage(value) {
+    return matchIn(CONTACT_LANGUAGES, value);
+}
+function matchIn(tags, value) {
+    const tag = canonicalLanguage(value);
+    if (!tag)
+        return null;
+    if (tags.includes(tag))
+        return tag;
+    const locale = new Intl.Locale(tag);
+    const hit = tags.find((l) => new Intl.Locale(l).language === locale.language);
+    if (!hit)
+        return null;
+    const excluded = (NOT_FALLBACK_FOR[hit] ?? []).some((x) => {
+        const ex = new Intl.Locale(x);
+        return ex.language === locale.language && (!ex.region || ex.region === locale.region);
+    });
+    return excluded ? null : hit;
+}
+let displayNames = null;
+/** A language's name in English, for prompts (`zh` → `Chinese`); the tag itself when it has none. */
+export function languageName(tag) {
+    try {
+        displayNames ??= new Intl.DisplayNames(['en'], { type: 'language' });
+        return displayNames.of(tag) ?? tag;
+    }
+    catch {
+        return tag;
+    }
 }
 //# sourceMappingURL=index.js.map

package/dist/core/functions/errors.d.ts

@@ -0,0 +1,74 @@
+import type { PageTablesDesc } from '../page/typed.js';
+import type { ExchangeRef } from '../context/exchanges.js';
+import type { Ctx } from './types.js';
+/**
+ * Errors of the company's code (67): a failure its code did not catch (a throw, its time or memory up), or
+ * a text or email conversation the AI marked stuck, is recorded once and the company's `onError` (root
+ * `errors.ts`) runs for it, in the background. What happens at the moment is the platform's and depends
+ * only on the channel (67 §3). The company does not throw errors of its own: what its code foresees, it
+ * handles where it happens. The platform's own failures are the platform's, not the company's (67 §4.4).
+ */
+/** The module at the repository root `onError` is exported from. */
+export declare const ERRORS_MODULE = "errors";
+/** `onError`'s name in the company build's function registry. */
+export declare const ON_ERROR_FUNCTION = "onError";
+/**
+ * `crash` an uncaught throw, `timeout` / `memory` the call's limit, `stuck` the AI marked a text or email
+ * conversation stuck, `platform` the platform failed and what the code was doing was not done (74 §3.2: an
+ * Orchestrator run the platform cut off or could not run, or a {@link PlatformUnavailableError} not caught).
+ */
+export type CodeErrorKind = 'crash' | 'timeout' | 'memory' | 'stuck' | 'platform';
+/** What the company is told of a `platform` error (74 §3.2): the platform's own failure stays in its logs and alerts. */
+export declare const PLATFORM_UNAVAILABLE_MESSAGE = "The platform was temporarily unavailable; we have been alerted.";
+/**
+ * A `ctx.api` call the platform could not answer (74 §3.2): it was unreachable, or failed on its side, after
+ * the tries it was worth. Not caught, it is a `platform` error (we are alerted, `onError` is told); caught and
+ * thrown again as another error, it is the code's own.
+ */
+export declare class PlatformUnavailableError extends Error {
+    readonly name = "PlatformUnavailableError";
+    /** The platform's refusal reason, when it gave one (`error.code`, as on any `ctx.api` error). */
+    code?: string;
+}
+/** What failed: the kind of entry, and its name (a function's, an event's, a job's, the page's `render` / `start` / `action:<name>`). */
+export type CodeErrorSourceType = 'resolve' | 'page' | 'function' | 'event' | 'orchestrator' | 'schedule' | 'webhook' | 'conversation';
+/** At most this much JSON for `args` (67 §4.2): bigger is cut, and says so. */
+export declare const ERROR_JSON_MAX_BYTES: number;
+/** One error, as `onError` gets it (`args.error`). */
+export type CodeErrorEvent = {
+    /** The error's id: find it in the error view, say it to the platform's team. */
+    id: string;
+    kind: CodeErrorKind;
+    message: string;
+    /** Where your code threw, in your files; none for `timeout`, `memory`, `stuck`, `platform`. */
+    stack?: string;
+    source: {
+        type: CodeErrorSourceType;
+        name: string;
+    };
+    /** The published company build whose code ran; null when a repository was being served. */
+    buildId: string | null;
+    at: string;
+    ids: {
+        sequenceId?: string;
+        instanceId?: string;
+        contactId?: string;
+        runId?: string;
+    };
+    /** Who is waiting: the call (it was already ended), or a text's or email's exchange and what the customer sent. */
+    channel?: {
+        type: 'call';
+        callId?: string;
+    } | {
+        type: 'sms' | 'email';
+        exchange?: ExchangeRef;
+        waiting: string;
+    };
+    /** The arguments of the call that failed (cut at {@link ERROR_JSON_MAX_BYTES}). */
+    args?: unknown;
+};
+/** `onError` of `errors.ts`: `(ctx, { error })`, run once for each error, with no case. */
+export type OnError<D extends PageTablesDesc | undefined = undefined> = (ctx: Ctx<D>, args: {
+    error: CodeErrorEvent;
+}) => Promise<void>;
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/functions/errors.js

@@ -0,0 +1,26 @@
+/**
+ * Errors of the company's code (67): a failure its code did not catch (a throw, its time or memory up), or
+ * a text or email conversation the AI marked stuck, is recorded once and the company's `onError` (root
+ * `errors.ts`) runs for it, in the background. What happens at the moment is the platform's and depends
+ * only on the channel (67 §3). The company does not throw errors of its own: what its code foresees, it
+ * handles where it happens. The platform's own failures are the platform's, not the company's (67 §4.4).
+ */
+/** The module at the repository root `onError` is exported from. */
+export const ERRORS_MODULE = 'errors';
+/** `onError`'s name in the company build's function registry. */
+export const ON_ERROR_FUNCTION = 'onError';
+/** What the company is told of a `platform` error (74 §3.2): the platform's own failure stays in its logs and alerts. */
+export const PLATFORM_UNAVAILABLE_MESSAGE = 'The platform was temporarily unavailable; we have been alerted.';
+/**
+ * A `ctx.api` call the platform could not answer (74 §3.2): it was unreachable, or failed on its side, after
+ * the tries it was worth. Not caught, it is a `platform` error (we are alerted, `onError` is told); caught and
+ * thrown again as another error, it is the code's own.
+ */
+export class PlatformUnavailableError extends Error {
+    name = 'PlatformUnavailableError';
+    /** The platform's refusal reason, when it gave one (`error.code`, as on any `ctx.api` error). */
+    code;
+}
+/** At most this much JSON for `args` (67 §4.2): bigger is cut, and says so. */
+export const ERROR_JSON_MAX_BYTES = 16 * 1024;
+//# sourceMappingURL=errors.js.map

package/dist/core/functions/events.d.ts

@@ -1,19 +1,17 @@
 import { z } from 'zod';
-import type { CaseInput } from '../case-orchestrator/types.js';
-import type { PageTablesDesc } from '../page/typed.js';
-import type { FunctionCtx, FunctionKind } from './types.js';
-import type { ExchangeRef } from '../context/exchanges.js';
+import type { Id, PageTablesDesc } from '../page/typed.js';
+import type { Ctx } from './types.js';
 /**
  * Platform events.
  *
  * The event name is the key of the company `events` export. For every event the
- * platform fixes the payload, the return type (`void` for every event except
- * `webhook.received`, which returns a {@link WebhookOutcome}) and whether the
- * handler receives `c` — companies only choose which events to subscribe to.
+ * platform fixes the payload and the return type (`void` for every event; `webhook.received`, a
+ * function of its own, returns a {@link WebhookOutcome}) — companies only choose which events to
+ * subscribe to.
  *
- * A handler is the company's own code, not the conversation: it does not get the page. `c` is the
- * case ({@link CaseInput}: the instance and its business root's id, as the Orchestrator gets it); it
- * reads and writes with `ctx.api.db`. Only `webhook.received` has no `c`: it runs before a case is known.
+ * A handler is a function like any other (38 §2.2): `(ctx, { event, subject, instanceId })`, the
+ * company's own code, not the conversation's: it does not get the page. It reads and writes with
+ * `ctx.api.db`.
  *
  * Payloads are provider-neutral on purpose: Twilio / Gmail vocabulary is
  * translated in the channel adapter, never carried into these types.
@@ -66,8 +64,6 @@ export type EmailReceivedEvent = EmailEventBase & {
 export type EmailSendRequestedEvent = EmailEventBase & {
     requestedAt: string;
 };
-/** Events that carry no payload yet: the handler reads what it needs from `c` and `ctx.api.db`. */
-export type EmptyEvent = Record<string, never>;
 /**
  * The HTTP request exactly as the gateway saw it. The platform verifies nothing: every header,
  * the absolute URL and the raw body are forwarded so the handler can check the sender's signature.
@@ -127,112 +123,61 @@ export type WebhookOutcome = {
 };
 /** Wire schema of {@link WebhookOutcome}; the worker validates the handler's return with it. */
 export declare const webhookOutcome: z.ZodType<WebhookOutcome>;
-/**
- * A text or email conversation needs a person (20 §5.7, 24 §5.3): the AI marked it stuck, or its run
- * failed; nothing was sent for what the customer wrote. The company decides who is told and how (a
- * task, a message to the team, a field on the case).
- */
-export type ConversationHandoffEvent = {
-    /** A call only when its model failed and the call was ended (25 §12); a stuck call reads `session.stuck`. */
-    channel: 'call' | 'sms' | 'email';
-    /** The exchange waiting for a person: the call, the text line, the email thread (21 §11.4). */
-    exchange: ExchangeRef;
-    /** The run that stopped. */
-    runId: string;
-    contactId: string;
-    /** Why: the AI marked the conversation stuck, or the run failed. */
-    cause: 'stuck' | 'error';
-    /** What went wrong, when the run failed. */
-    error?: string;
-    /** What the customer sent that is waiting for an answer. */
-    waiting: string;
-    at: string;
-};
-/** Event name → { whether the handler gets `c`, payload, handler return }. */
+/** Event name → { payload, handler return }. */
 export type SystemEventMap = {
     'call.inbound': {
-        case: true;
         event: CallInboundEvent;
         result: void;
     };
     'call.outbound': {
-        case: true;
         event: CallOutboundEvent;
         result: void;
     };
     'call.ended': {
-        case: true;
         event: CallEndedEvent;
         result: void;
     };
     'sms.received': {
-        case: true;
         event: SmsReceivedEvent;
         result: void;
     };
     'sms.send-requested': {
-        case: true;
         event: SmsSendRequestedEvent;
         result: void;
     };
     'email.received': {
-        case: true;
         event: EmailReceivedEvent;
         result: void;
     };
     'email.send-requested': {
-        case: true;
         event: EmailSendRequestedEvent;
         result: void;
     };
-    /** A conversation needs a person (20 §5.7): a text or email stuck or failed, a call whose model failed (25 §12). */
-    'conversation.handoff': {
-        case: true;
-        event: ConversationHandoffEvent;
-        result: void;
-    };
-    /**
-     * Reserved and unused: the platform does not send it yet (the Orchestrator hands a run to the next
-     * sequence with `scheduleNextSequence`).
-     */
-    'sequence.next': {
-        case: true;
-        event: EmptyEvent;
-        result: void;
-    };
 };
 export type SystemEventName = keyof SystemEventMap;
 export type SystemEventPayload<K extends SystemEventName> = SystemEventMap[K]['event'];
 export type SystemEventResult<K extends SystemEventName> = SystemEventMap[K]['result'];
-/**
- * Runtime table mirroring {@link SystemEventMap}. The build uses it to pick the
- * registry kind of each handler; the dispatcher uses it to pick the invocation path.
- */
+/** Runtime table mirroring {@link SystemEventMap}: the events a handler may be written for. */
 export declare const SYSTEM_EVENTS: {
-    readonly [K in SystemEventName]: {
-        readonly case: SystemEventMap[K]['case'];
-    };
+    readonly [K in SystemEventName]: true;
 };
 export declare const SYSTEM_EVENT_NAMES: readonly SystemEventName[];
 export declare function isSystemEventName(value: string): value is SystemEventName;
-/** Registry kind of an event handler: fixed per event by {@link SYSTEM_EVENTS}. */
-export declare function systemEventKind(name: SystemEventName): Extract<FunctionKind, 'case' | 'noCase'>;
-export type EventHandlerParams<K extends SystemEventName> = {
+/** What a handler is called with (38 §2.2): the event, and the instance it is on and its business root. */
+export type EventHandlerArgs<K extends SystemEventName, S extends string = string> = {
     event: SystemEventPayload<K>;
+    subject: Id<S>;
+    instanceId: string;
 };
-/**
- * Handler signature for one event; whether it gets `c` (the case) and the return type come from the
- * event table. Like any function, a handler reads and writes with `ctx.api.db`, typed by the sequence's
- * `PageTables` (`D`).
- */
-export type EventHandler<C, K extends SystemEventName, D extends PageTablesDesc | undefined = undefined> = SystemEventMap[K]['case'] extends true ? (c: C, ctx: FunctionCtx<EventHandlerParams<K>, D>) => Promise<SystemEventResult<K>> : (ctx: FunctionCtx<EventHandlerParams<K>, D>) => Promise<SystemEventResult<K>>;
+/** Handler for one event: `(ctx, { event, subject, instanceId })`; `D` types `ctx.api.db`, `S` the business root. */
+export type EventHandler<K extends SystemEventName, D extends PageTablesDesc | undefined = undefined, S extends string = string> = (ctx: Ctx<D>, args: EventHandlerArgs<K, S>) => Promise<SystemEventResult<K>>;
 /** Company `events` export: subscribe to any subset of platform events. */
-export type EventHandlers<C = CaseInput, D extends PageTablesDesc | undefined = undefined> = {
-    [K in SystemEventName]?: EventHandler<C, K, D>;
+export type EventHandlers<D extends PageTablesDesc | undefined = undefined, S extends string = string> = {
+    [K in SystemEventName]?: EventHandler<K, D, S>;
 };
-/** Loader/host-side view of an events map: handler `c` and `ctx` types are not known. */
+/** Loader/host-side view of an events map: handler argument types are not known. */
 export type AnyEventHandlers = {
-    [K in SystemEventName]?: (...args: any[]) => Promise<unknown>;
+    [K in SystemEventName]?: (ctx: any, args: any) => Promise<unknown>;
 };
 /** The company function that receives webhooks: `received` of `webhook.ts` at the repository root. */
 export declare const WEBHOOK_RECEIVED_FUNCTION = "webhook.received";
@@ -241,7 +186,7 @@ export declare const WEBHOOK_RECEIVED_FUNCTION = "webhook.received";
  * `event.webhook.name`. It runs with no sequence; to hand a request to one, start an instance or call
  * its code through the platform API. Return accepted / rejected explicitly; throw to be retried.
  */
-export type WebhookHandler<D extends PageTablesDesc | undefined = undefined> = (ctx: FunctionCtx<{
+export type WebhookHandler<D extends PageTablesDesc | undefined = undefined> = (ctx: Ctx<D>, args: {
     event: WebhookEvent;
-}, D>) => Promise<WebhookOutcome>;
+}) => Promise<WebhookOutcome>;
 //# sourceMappingURL=events.d.ts.map

package/dist/core/functions/events.js

@@ -4,29 +4,20 @@ export const webhookOutcome = z.discriminatedUnion('status', [
     z.object({ status: z.literal('accepted') }),
     z.object({ status: z.literal('rejected'), reason: z.string() }),
 ]);
-/**
- * Runtime table mirroring {@link SystemEventMap}. The build uses it to pick the
- * registry kind of each handler; the dispatcher uses it to pick the invocation path.
- */
+/** Runtime table mirroring {@link SystemEventMap}: the events a handler may be written for. */
 export const SYSTEM_EVENTS = {
-    'call.inbound': { case: true },
-    'call.outbound': { case: true },
-    'call.ended': { case: true },
-    'sms.received': { case: true },
-    'sms.send-requested': { case: true },
-    'email.received': { case: true },
-    'email.send-requested': { case: true },
-    'conversation.handoff': { case: true },
-    'sequence.next': { case: true },
+    'call.inbound': true,
+    'call.outbound': true,
+    'call.ended': true,
+    'sms.received': true,
+    'sms.send-requested': true,
+    'email.received': true,
+    'email.send-requested': true,
 };
 export const SYSTEM_EVENT_NAMES = Object.keys(SYSTEM_EVENTS);
 export function isSystemEventName(value) {
     return Object.hasOwn(SYSTEM_EVENTS, value);
 }
-/** Registry kind of an event handler: fixed per event by {@link SYSTEM_EVENTS}. */
-export function systemEventKind(name) {
-    return SYSTEM_EVENTS[name].case ? 'case' : 'noCase';
-}
 /** The company function that receives webhooks: `received` of `webhook.ts` at the repository root. */
 export const WEBHOOK_RECEIVED_FUNCTION = 'webhook.received';
 //# sourceMappingURL=events.js.map

package/dist/core/functions/schedules.d.ts

@@ -1,12 +1,12 @@
 import type { PageTablesDesc } from '../page/typed.js';
-import type { FunctionCtx } from './types.js';
+import type { Ctx } from './types.js';
 /**
- * Recurring jobs (25 §6.4): `schedules.ts` at the repository root (company level, next to
- * `webhook.ts`) or in `sequences/<id>/` (sequence level). Each runs on its cron in every environment
+ * Recurring jobs (25 §6.4): `schedules.ts` at the repository root, next to `webhook.ts`; the
+ * company's only (a sequence has none). Each runs on its cron in every environment
  * whose live release has it, with no case and no contact; `ctx.api` is the webhook handler's
  * (`db`, `integration`, `instances.start`, `instances.notify`, `log`, `kv`).
  */
-/** What `ctx.params.schedule` tells a run: which job, and the tick it runs for. */
+/** What a job's `run` is told (`args.schedule`): which job, and the tick it runs for. */
 export type ScheduleTick = {
     /** The job's key in `defineSchedules({ … })`. */
     name: string;
@@ -15,16 +15,15 @@ export type ScheduleTick = {
     /** The tick this run is for (ISO). A run made up after the worker was down has the missed tick's time. */
     scheduledAt: string;
 };
-export type ScheduleCtx<D extends PageTablesDesc | undefined = undefined> = FunctionCtx<{
-    schedule: ScheduleTick;
-}, D>;
 export type ScheduleDefinition<D extends PageTablesDesc | undefined = undefined> = {
     /** Five fields: minute hour day-of-month month day-of-week (`'0 2 * * *'`: every day at 02:00). */
     cron: string;
     /** IANA name the cron is read in (`'UTC'`, `'America/Phoenix'`). */
     timezone: string;
     /** Throw to have the run recorded as failed; it is not retried, the next tick runs as usual. */
-    run: (ctx: ScheduleCtx<D>) => Promise<void>;
+    run: (ctx: Ctx<D>, args: {
+        schedule: ScheduleTick;
+    }) => Promise<void>;
 };
 /** The `schedules` export: job name → definition. */
 export type Schedules<D extends PageTablesDesc | undefined = undefined> = Record<string, ScheduleDefinition<D>>;
@@ -33,12 +32,12 @@ export type Schedules<D extends PageTablesDesc | undefined = undefined> = Record
  *
  * ```ts
  * export const schedules = defineSchedules({
- *   nightlySync: { cron: '0 2 * * *', timezone: 'UTC', run: async (ctx) => { … } },
+ *   nightlySync: { cron: '0 2 * * *', timezone: 'UTC', run: async (ctx, { schedule }) => { … } },
  * });
  * ```
  */
 export declare function defineSchedules<D extends PageTablesDesc | undefined = undefined>(schedules: Schedules<D>): Schedules<D>;
-/** The module a repository root or a sequence defines its jobs in. */
+/** The module the repository root defines its jobs in. */
 export declare const SCHEDULES_MODULE = "schedules";
 /** A job's name in the build's function registry: `schedule.<name>` (a `noCase` function). */
 export declare const SCHEDULE_FUNCTION_PREFIX = "schedule.";

package/dist/core/functions/schedules.js

@@ -3,14 +3,14 @@
  *
  * ```ts
  * export const schedules = defineSchedules({
- *   nightlySync: { cron: '0 2 * * *', timezone: 'UTC', run: async (ctx) => { … } },
+ *   nightlySync: { cron: '0 2 * * *', timezone: 'UTC', run: async (ctx, { schedule }) => { … } },
  * });
  * ```
  */
 export function defineSchedules(schedules) {
     return schedules;
 }
-/** The module a repository root or a sequence defines its jobs in. */
+/** The module the repository root defines its jobs in. */
 export const SCHEDULES_MODULE = 'schedules';
 /** A job's name in the build's function registry: `schedule.<name>` (a `noCase` function). */
 export const SCHEDULE_FUNCTION_PREFIX = 'schedule.';

package/dist/core/functions/types.d.ts

@@ -1,89 +1,34 @@
-import type { CaseOrchestrator } from '../case-orchestrator/types.js';
 import type { SystemContext } from '../context/types.js';
-import type { CaseInput } from '../case-orchestrator/types.js';
 import type { Db } from '../page/define.js';
 import type { PageTablesDesc, TypedDb } from '../page/typed.js';
-export type FuncOptions = {
-    args?: Record<string, unknown>;
-    description?: string;
-};
-/**
- * Runtime function kinds. All of them take `ctx` and run on the Worker host; a host only needs to
- * know whether a function takes `c` (the case).
- *
- * | kind               | signature                  | host    |
- * | ------------------ | -------------------------- | ------- |
- * | `case`             | `(c, ctx) => R`            | Worker  |
- * | `noCase`           | `(ctx) => R`               | Worker  |
- * | `orchestrator` | `(c, ctx) => R`            | Worker  |
- *
- * `define*` names map 1:1 onto kinds; tooling derives the kind from the define name.
- * `orchestrator` has no define: the compiler stamps it on `orchestrator.ts`, and its `ctx`
- * is a `CaseOrchestratorContext` instead of a `SystemContext`.
- */
-export type FunctionKind = 'case' | 'noCase' | 'orchestrator';
-/** Kinds that take `ctx` and run on the Worker host. */
-export declare const WORKER_FUNCTION_KINDS: readonly ['case', 'noCase', 'orchestrator'];
-export type WorkerFunctionKind = (typeof WORKER_FUNCTION_KINDS)[number];
-export declare function isWorkerFunctionKind(kind: string): kind is WorkerFunctionKind;
 /**
- * `ctx` of every function. `ctx.api.db` reads and writes records like a page script and its actions
- * (15 §10.15 task 4): any row of the company and environment, each write its own transaction. `D` (the sequence's `PageTables`, bound by `__gen`) types them.
+ * `ctx` of every function and entry (38 §2.3): what it is called with besides its `args`. `ctx.api.db`
+ * reads and writes records like a page script and its actions (15 §10.15 task 4): any row of the
+ * company and environment, each write its own transaction. `D` (the company's `PageTables`, bound by
+ * `__gen`) types them.
  */
-export type FunctionCtx<Params extends object, D extends PageTablesDesc | undefined = undefined> = Omit<SystemContext, 'api'> & {
+export type Ctx<D extends PageTablesDesc | undefined = undefined> = Omit<SystemContext, 'api' | 'meta'> & {
+    /** What runs, where (38 §2.3): the instance a function works on is in its `args`, not here. */
+    meta: Omit<SystemContext['meta'], 'instanceId'>;
     api: Omit<SystemContext['api'], 'db'> & {
         db: D extends PageTablesDesc ? TypedDb<D> : Db;
     };
-    params: Params;
 };
 /**
- * Bound to a case: `(c, ctx)`, `c` the case — the instance and its business root's id ({@link CaseInput}),
- * not the page (the page is the conversation's). Return value is caller-defined (event handlers return nothing).
+ * A function as the company writes it (38 §2.1): `(ctx, args)`, `args` one object (`{}` when it takes
+ * none). Every entry the platform calls (functions, event handlers, `resolve`, the webhook, a schedule's
+ * `run`, the Orchestrator) is one; the platform tells its entries apart by name.
  */
-export type CaseFn<S = CaseInput, P extends object = object, R = unknown, D extends PageTablesDesc | undefined = undefined> = (c: S, ctx: FunctionCtx<P, D>) => Promise<R>;
-/** Not bound to a case: `(ctx)` only. */
-export type NoCaseFn<P extends object = object, R = unknown, D extends PageTablesDesc | undefined = undefined> = (ctx: FunctionCtx<P, D>) => Promise<R>;
-type FuncMeta = {
-    description?: string;
-    args?: Record<string, unknown>;
-};
-export type DefinedCaseFunc<S = CaseInput, P extends object = object, R = unknown, D extends PageTablesDesc | undefined = undefined> = FuncMeta & {
-    kind: 'case';
-    main: CaseFn<S, P, R, D>;
-};
-export type DefinedNoCaseFunc<P extends object = object, R = unknown, D extends PageTablesDesc | undefined = undefined> = FuncMeta & {
-    kind: 'noCase';
-    main: NoCaseFn<P, R, D>;
-};
-/** The `orchestrator.ts` entry point, registered by the compiler (never authored in `functions`). */
-export type DefinedCaseOrchestratorFunc<S = CaseInput> = FuncMeta & {
-    kind: 'orchestrator';
-    main: CaseOrchestrator<S>;
-};
+export type PlainFn = (ctx: any, args: any) => Promise<unknown>;
+/** Author map: key is the function name. */
+export type FuncMap = Record<string, PlainFn>;
 /**
- * One entry in a plain `functions` map (`{ name: define*Func(...) }`).
- * Generics are kept (not erased) for the typed helpers that read a function's signature.
+ * Compiled function registry entry (JSON-safe). Same shape for `functions` and `events`. `code` is the
+ * standalone JS function expression (esbuild-normalized): present on published builds, omitted on the
+ * local serve overlay (`includeCode: false`).
  */
-export type DefinedFunc<S = any, P extends object = any, R = any> = DefinedCaseFunc<S, P, R> | DefinedNoCaseFunc<P, R> | DefinedCaseOrchestratorFunc<S>;
-/** Author map: key is the function name. */
-export type FuncMap = Record<string, DefinedFunc>;
-/** Map entry with name stamped from the key (for platform loaders). */
-export type FuncRegistration = DefinedFunc & {
-    name: string;
-};
-type RegistryCode = {
-    /**
-     * Standalone JS function expression (esbuild-normalized).
-     * Present on published builds; omitted on local serve overlay (`includeCode: false`).
-     */
+export type FunctionRegistryEntry = {
     code?: string;
 };
-/** Compiled function registry entry (JSON-safe). Same shape for `functions` and `events`. */
-export type FunctionRegistryEntry = RegistryCode & {
-    kind: FunctionKind;
-};
 export type FunctionRegistry = Record<string, FunctionRegistryEntry>;
-/** Plain-object FuncMap → array with `name` stamped (platform-side loaders). */
-export declare function toFuncRegistrations(functions: FuncMap): FuncRegistration[];
-export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/core/functions/types.js

@@ -1,10 +1,2 @@
-/** Kinds that take `ctx` and run on the Worker host. */
-export const WORKER_FUNCTION_KINDS = ['case', 'noCase', 'orchestrator'];
-export function isWorkerFunctionKind(kind) {
-    return WORKER_FUNCTION_KINDS.includes(kind);
-}
-/** Plain-object FuncMap → array with `name` stamped (platform-side loaders). */
-export function toFuncRegistrations(functions) {
-    return Object.entries(functions).map(([name, def]) => ({ ...def, name }));
-}
+export {};
 //# sourceMappingURL=types.js.map