@superpanel-sdk/runtime 0.5.0 → 0.7.0

package/dist/core/page/define.d.ts

@@ -3,13 +3,14 @@
  * inside the QuickJS sandbox, bundled into the page script, so it imports nothing at runtime and only
  * uses `globalThis.__host` (the sandbox's async host call, services `page/sandbox.ts`).
  *
- * A page script reads with `db` and returns a free-form document: objects are blocks, arrays are
- * lists, a slot is a cell, `field(slot, …)` a cell with page settings, other plain values read-only
- * content, and actions (`createRow`, `deleteRow`, `defineAction`) buttons. The platform turns the
- * document into a `RenderedPage` (`render.ts`).
+ * A page script reads with `db` and returns a page written with functions (76): `page(…)`, or
+ * `doNow(…)` to do something first. The page functions (`fns.ts`) are built from what is here (a
+ * field's cell, a button's action) and cross the sandbox as an envelope; the platform turns it into a
+ * `RenderedPage` (`render.ts`).
  */
-import type { Channel, Direction } from '../conversation/index.js';
+import { type Channel, type Direction, type Spoken } from '../conversation/index.js';
 import type { TimelineEntry, TimelineWhere } from './timeline.js';
+import type { TimeParts } from './time-format.js';
 export type SlotState = 'filled' | 'empty' | 'asked_unknown' | 'declined';
 export type SlotRef = {
     table: string;
@@ -39,9 +40,16 @@ export type FindArgs = {
     orderBy?: Record<string, 'asc' | 'desc'> | Array<Record<string, 'asc' | 'desc'>>;
     take?: number;
     skip?: number;
-    cursor?: {
-        id: string;
-    };
+    /**
+     * Where a page starts: a row as `db` returned it, normally the last of the page before. The rows
+     * strictly after it in this read's order come (`orderBy`, then creation, then id; rows without a
+     * value of the order field last), then `skip`. Read by value, never looked up: a row deleted or
+     * changed since still marks where it was. It needs the row's `id` and `createdAt`, its `updatedAt`
+     * when ordered by that, and the slot of each field ordered by (keep it in `select`). Only that place
+     * is sent (over `ctx.api.db`, not the rest of the row and what it included); an order value not of
+     * its field's type is refused.
+     */
+    after?: PageRow;
 };
 /** One table's read methods (Prisma Client's read-only subset). */
 export type TableReader<Row = PageRow> = {
@@ -114,6 +122,8 @@ export type PageConversation = {
     isNewContact: boolean;
     /** ISO timestamp the session opened. */
     startedAt: string;
+    /** The provider's id of the call (Twilio's CallSid, 62), as the resolve got it; null when unknown. */
+    externalId: string | null;
 };
 /**
  * Counts over this instance, worked out when the page renders (11-remove-sequence-schema §3.3.1).
@@ -167,37 +177,73 @@ export type PageActionRun = {
 export declare function tried(runs: PageRuns | null | undefined, key: string, scope?: ActionRunScope): boolean;
 /** The latest run of the action `key`, in this run or (`'case'`) on the case, if any. */
 export declare function lastActionRun(runs: PageRuns | null | undefined, key: string, scope?: ActionRunScope): PageActionRun | null;
-/** An agreed follow-up: the channel, when (ISO), and what it is about. */
-export type PageFollowUp = {
-    channel: string;
-    scheduledFor: string;
-    note: string | null;
+/**
+ * The case's next step (40 §2.2): its pending contact — when, on which channel, whom, why, and where it
+ * was booked. Independent appointments may coexist (51); the platform shows them after every conversation page.
+ */
+export type PageNextStep = {
+    id: string;
+    name?: string | null;
+    channel: 'call' | 'sms' | 'email';
+    /** When it runs, ISO 8601. */
+    at: string;
+    /** Whom it contacts: the contact's id, and what they are called (their name, else their phone or email; null when none is on file). */
+    contact: {
+        id: string;
+        name: string | null;
+    };
+    /** Why (40 §2.6); null when nobody said. */
+    reason: string | null;
+    /** The contact's own words asking for it or agreeing to it (an agreed follow-up, 09); null otherwise. */
+    customerQuote: string | null;
+    /** The conversation it was booked in, its channel and when it started; null: booked outside one (the Orchestrator, company code). */
+    bookedIn: {
+        channel: 'call' | 'sms' | 'email';
+        at: string;
+    } | null;
 };
 /**
- * The button that books what the customer just asked for or agreed to (25 §5): a call back, a text, an
- * email, at the time they said. The platform books it at once as an agreed follow-up (09): the exchange
- * and the time of their words are its own; the AI gives the channel, the time and their words.
+ * The button that books the case's next step (40 §2.2): what the customer asked for or agreed to, or
+ * what the AI decides the case needs. The AI gives when, the channel, why, and the customer's words
+ * when they said it (an agreed follow-up, 09); whom is the conversation's contact unless the page lets
+ * the AI choose (`options`) or fixes one (`prefill`). It adds an independent appointment, or edits one explicitly by ID (51).
  */
 export type FollowUpAction = {
     $action: 'followUp';
     /** The run key (default `followUp`). */
     key: string;
-    /** The channels the customer may be followed up on, of the ones this sequence has a page for. */
+    /** The channels it may book, of the ones this sequence has a page for. */
     channels: Array<'call' | 'sms' | 'email'>;
+    /** What the page fixed: the channel (one of `channels`), whom (a contact row's id); `contactId: choose(...)`: the contacts the AI chooses among. */
+    prefill?: {
+        channel?: 'call' | 'sms' | 'email';
+        contactId?: string | ChooseParam;
+    };
     label?: string;
     description?: string;
 };
-/** `ctx.followUps`: the agreed follow-ups still to come, and `agree(...)`, the button that books one. */
-export type PageFollowUps = PageFollowUp[] & {
-    agree(options: {
-        channels: Array<'call' | 'sms' | 'email'>;
-        key?: string;
-        label?: string;
-        description?: string;
-    }): FollowUpAction;
-};
-/** The agreed follow-ups with the button that books one. */
-export declare function pageFollowUps(list: readonly PageFollowUp[]): PageFollowUps;
+/** The button that cancels the case's next step (40 §2.2), with why. */
+export type CancelFollowUpAction = {
+    $action: 'cancelFollowUp';
+    /** The run key (default `cancelFollowUp`). */
+    key: string;
+    label?: string;
+    description?: string;
+};
+/** The next-step button (`scheduleFollowUp({ channels })`, 76). */
+export declare function followUpAction(options: {
+    channels: Array<'call' | 'sms' | 'email'>;
+    key?: string;
+    label?: string;
+    description?: string;
+    prefill?: Record<string, unknown>;
+}): FollowUpAction;
+/** The cancel-next-step button (`cancelFollowUp()`, 76). */
+export declare function cancelFollowUpAction(options?: {
+    key?: string;
+    label?: string;
+    description?: string;
+}): CancelFollowUpAction;
 /**
  * One FAQ entry (24 §7): its id, what it covers (the catalog in the prompt shows these two), and the
  * answer (the AI fetches it with `get_faq`).
@@ -242,13 +288,15 @@ export type PageBaseContext = {
         }>;
     } | null;
     /**
-     * The contact's agreed follow-ups still to come (09): calls and messages they asked for or agreed to,
-     * soonest first. Empty without a Case Orchestrator (nothing books them). `ctx.followUps.agree({ channels })`
-     * is the button that books one when the customer asks for it (25 §5).
+     * The case's independent pending contact appointments (51), soonest first. The platform shows
+     * their stable IDs before the page. `scheduleFollowUp()` adds or edits one; `cancelFollowUp()`
+     * cancels an explicit target. Empty when nothing is booked.
      */
-    followUps: PageFollowUps;
+    nextSteps: PageNextStep[];
     /** The business root's id. */
     subject: string;
+    /** The instance this conversation is on: prefill it to a function that needs it (38 §2.2). */
+    instanceId: string;
     /** The contact of the conversation; null outside one. */
     caller: PageRow | null;
     /** This conversation's session row (the session fields, cells); null outside one. */
@@ -259,10 +307,13 @@ export type PageBaseContext = {
     history: PageHistory;
     /** ISO timestamp of this render. */
     now: string;
-    /** A text or an email to send now (25 §8): `ctx.messages.text('link', { body })`. */
-    messages: PageMessages;
     /** Times for people (25 §11): the sandbox has no `Intl`, so formatting goes through the platform. */
     time: PageTime;
+    /**
+     * The environment's configuration, read only (76 §2.19): the values of its `env` integrations, the
+     * same functions read with `ctx.api.integration.envs`; null when no `env` integration has the key.
+     */
+    env: PageEnv;
 };
 /**
  * `ctx.time` (25 §11): the contact's time zone and today there, `format` for a time as people read it,
@@ -281,6 +332,10 @@ export type PageTime = {
     }): Promise<string>;
     /** The calendar day (`YYYY-MM-DD`) at `at` in `timeZone` (default `zone`), to compare days or key a rule by date. */
     day(at: string | number, timeZone?: string): Promise<string>;
+    /** The exact moment (ISO, UTC) a clock in `timeZone` (default `zone`) shows `date` at `time` (`HH:mm`), 74 §4.7. */
+    at(date: string, time: string, timeZone?: string): Promise<string>;
+    /** `at` on a clock in `timeZone` (default `zone`): date, `HH:mm`, hour, minute, ISO weekday, offset (74 §4.7). */
+    parts(at: string | number, timeZone?: string): Promise<TimeParts>;
 };
 /**
  * A text the customer sent since the last run (20 §5.2): what this run is for. `earlier`: sent before,
@@ -329,27 +384,40 @@ export type PagePreviousCall = {
     }>;
 };
 /**
- * Who answered an outbound call (25 §13), as the voice service tells it: a person, a voicemail greeting,
- * a call-screening assistant, a phone menu; `said`: what it said. The page decides what to do: leave a
- * message (`ctx.call.voicemail`), tell the screener who calls and why (`announce`), press keys (`keypad`),
- * end. A page that returns nothing for it leaves the voice service to do what it does on its own (hang
- * up on a machine).
+ * A voicemail greeting answered the outbound call, as the voice service tells it (65 §3.1); `said`: what
+ * it said. The page decides what to do: leave a message (`doNow(voicemail({ … }))`), or end (a full mailbox). A page
+ * that returns nothing for it has the voice service hang up. Anything else that answers (a person, a
+ * call-screening assistant, a phone menu) the page's model tells from the words; the page writes what to do.
  */
 export type PageFarEnd = {
-    kind: 'human' | 'voicemail' | 'screening' | 'ivr';
+    kind: 'voicemail';
     said: string;
 };
-/** What only a call can do (20 §5.2): on `ctx.call`, so a text's page cannot even write it. */
+/**
+ * The words this render answers (65 §3.2): what the person just said; `first`, the far end's first words
+ * on an outbound call, before the AI said anything (a "Hello?" can get the opening line at once, a long
+ * first sentence is the model's to answer). Null when the render answers no words (the opening, an event).
+ */
+export type PageHeard = {
+    text: string;
+    first: boolean;
+};
+/** What only a call has (20 §5.2): on `ctx.call`. A call's own buttons (transfers, `keypad`) are left off a text's page (76 §2.12). */
 export type PageCallCaps = {
-    transferTo: typeof transferTo;
-    keypad: typeof keypad;
-    announce: typeof announce;
-    voicemail: typeof voicemail;
     /** This person's previous call on this case; null when there is none. */
     previous: PagePreviousCall | null;
-    /** Who answered, once the voice service knows (25 §13); null until then, and on an inbound call. */
+    /** A voicemail answered, once the voice service knows (65 §3.1); null otherwise, and on an inbound call. */
     farEnd: PageFarEnd | null;
+    /** The words this render answers (65 §3.2); null when it answers none. */
+    heard: PageHeard | null;
+    /**
+     * `live` while the call is on the line; `wrapup` once it has hung up and the AI finishes what the call
+     * left (40 §2.5): fields, buttons that need no line, notes. Nothing said is heard then.
+     */
+    phase: PageCallPhase;
 };
+/** Where a call is (40 §2.5): on the line, or its wrap-up after the hang-up. */
+export type PageCallPhase = 'live' | 'wrapup';
 /** What each channel adds to the page function's context (20 §5.2). */
 export type PageChannelCaps = {
     call: {
@@ -433,24 +501,34 @@ export type RefFieldCell<S = Slot> = {
     readOnly?: boolean;
 };
 /**
- * A parameter taken from the schema (`schemaField('providers.name')`): the platform fills in its type,
- * allowed values, label and `extraction` (the page's `extraction` replaces the schema's). `table.id`,
- * or a lookup field, chooses a row on the page.
+ * A parameter taken from the schema (an added row's fields, `createRow(table, { fields })`): the platform fills
+ * in its type, allowed values and `extraction`. `table.id`, or a lookup field, chooses a row on the page.
  */
 export type SchemaFieldParam = {
     $schemaField: string;
     extraction?: string;
 };
-/** `schemaField()` options. `description` was renamed `extraction` and is refused. */
-export type SchemaFieldOptions = {
-    extraction?: string;
-    description?: RenamedOption<'extraction'>;
-};
-/** One parameter of an action: a schema field, or plain JSON Schema (function call `parameters`). */
+/** One parameter of an action: plain JSON Schema as the build reads it from a function's `args` type (38 §2.4), or a schema field. */
 export type ActionParam = SchemaFieldParam | {
     type: 'string' | 'number' | 'integer' | 'boolean';
     description?: string;
     enum?: Array<string | number>;
+}
+/** A row of `table` (`Id<'table'>`, 38 §2.4): the page prefills it or gives the rows to choose among. */
+ | {
+    type: 'ref';
+    table: string;
+    description?: string;
+}
+/** A string in a format (`IsoDate`, `Phone`…, 38 §2.4). */
+ | {
+    type: 'date' | 'datetime' | 'time' | 'phone' | 'email';
+    description?: string;
+}
+/** When a contact may be reached (`ContactSchedule`, 25 §3): checked as a contact_schedule field's value is. */
+ | {
+    type: 'contact_schedule';
+    description?: string;
 } | {
     type: 'array';
     items: ActionParam;
@@ -470,6 +548,8 @@ export type ActionParameters = {
 export type CreateRowAction = {
     $action: 'createRow';
     table: string;
+    /** The run key (`runKey`); without it, `createRow:<table>`. */
+    key?: string;
     label?: string;
     description?: string;
     fields: string[];
@@ -480,6 +560,8 @@ export type CreateRowAction = {
 export type DeleteRowAction = {
     $action: 'deleteRow';
     rowId: string;
+    /** The run key (`runKey`); without it, `deleteRow:<row id>`. */
+    key?: string;
     label?: string;
     description?: string;
     reason?: string;
@@ -487,23 +569,35 @@ export type DeleteRowAction = {
 export type CustomAction = {
     $action: 'custom';
     name: string;
-    description: string;
-    parameters: ActionParameters;
+    /** How to fill each parameter on this page, by name (`run(…, { args })`, 31 §7): replaces the parameter's own. */
+    args?: Record<string, string>;
+    /** What the AI sees as its title (`button({ title })`); without it, `name`. */
+    label?: string;
+    /** The run key (`runKey`); without it, `name`. */
+    key?: string;
+    /** What the AI sees it does (`button({ does })`). */
+    description?: string;
+    /** What it takes; without them, its `args` type's, as the build read it (38 §2.9). */
+    parameters?: ActionParameters;
     /** Parameters filled where the page placed the action: kept on the server, never shown to the AI. */
     prefill: Record<string, unknown>;
 };
 /**
- * A company function (`functions/`, `defineCaseFunc`) as a button, or returned by the page function to
+ * A company function (`functions/`, 38 §2.1) as a button, or returned by the page function to
  * run now (20 §6.2). It runs on the Worker, outside the page's transaction, and is waited for; on a call,
  * `say` is said first and the customer cannot interrupt until it is done (20 §6.3).
  */
 export type FunctionAction = {
     $action: 'function';
     name: string;
+    /** How to fill each parameter on this page, by name (`run(…, { args })`, 31 §7): replaces the parameter's own. */
+    args?: Record<string, string>;
+    /** The run key (`runKey`); without it, `name`. */
+    key?: string;
     label?: string;
     description?: string;
-    /** Said first, verbatim, on a call only (ignored elsewhere): the customer only listens meanwhile. */
-    say?: string;
+    /** Said first, verbatim, on a call only (ignored elsewhere), in the call's language (66): the customer only listens meanwhile. */
+    say?: Spoken;
     /** What the AI fills: plain JSON Schema or schema fields, as a custom action's. */
     parameters?: ActionParameters;
     /** Parameters the page fills (a row's id) or offers rows for (`choose(...)`, 25 §10); kept on the server. */
@@ -524,43 +618,15 @@ export type ChooseParam = {
 };
 export declare function choose<R extends PageRow>(rows: readonly R[], label: (row: R) => string): ChooseParam;
 export declare function isChoose(value: unknown): value is ChooseParam;
-/**
- * A text or an email sent now (25 §8), on the platform's own way out: from this call's number (a text)
- * or the contact's mailbox (an email), opt-outs checked, recorded on the case and this run. What the page
- * leaves out the AI writes: `body`, and an email's `subject`.
- */
-export type MessageAction = {
-    $action: 'message';
-    channel: 'sms' | 'email';
-    /** The run key: `lastActionRun(ctx.runs, key)` says whether it went. */
-    key: string;
-    /** The contact it goes to (a contact row the page read); absent: the contact of this conversation. */
-    to?: string;
-    /** The text, word for word; absent: the AI writes it. */
-    body?: string;
-    /** An email's subject; absent: the AI writes it. */
-    subject?: string;
-    /** On a call, said once it went (`'I just texted you the link.'`); ignored elsewhere. */
-    say?: string;
-    label?: string;
-    description?: string;
-};
-export type MessageOptions = {
-    to?: PageRow | string;
-    body?: string;
-    say?: string;
-    label?: string;
-    description?: string;
-};
-/** `ctx.messages` (25 §8): a text or an email to send now, as a button or returned to run at once. */
-export type PageMessages = {
-    text(key: string, options?: MessageOptions): MessageAction;
-    email(key: string, options?: MessageOptions & {
-        subject?: string;
-    }): MessageAction;
-};
-export declare const messages: PageMessages;
-export type PageAction = CreateRowAction | DeleteRowAction | CustomAction | ChannelAction | FunctionAction | MessageAction | FollowUpAction;
+/** A platform tool on the page (76 §2.18): the AI presses it like a button and reads its result next turn. */
+export type ToolAction = {
+    $action: 'tool';
+    tool: PageToolName;
+};
+/** The platform's tools (76 §2.18). */
+export type PageToolName = 'pressKeypad' | 'convertTime';
+export declare const PAGE_TOOLS: readonly PageToolName[];
+export type PageAction = CreateRowAction | DeleteRowAction | CustomAction | ChannelAction | FunctionAction | FollowUpAction | CancelFollowUpAction | ToolAction;
 /** Hand the call to a person. */
 export type TransferAction = {
     $action: 'channel';
@@ -583,16 +649,35 @@ export type TransferAction = {
      * customer is put through once the person takes it. Nobody takes it: the conversation simply goes on.
      */
     mode: 'cold' | 'warm' | 'background';
+    /**
+     * What the briefing should cover (74 §3.3): the very words, or an instruction ("say who is calling and
+     * why"). A model writes it as two or three sentences read aloud to the person, from this and the
+     * conversation so far (at the opening, from this alone), in their `language`; field names, underscores
+     * and codes are said the way a person would say them.
+     */
     briefing?: string;
+    /**
+     * Warm and background (76 §2.9): what the person hears on a loop when they pick up, before they confirm:
+     * who it is and what about. The platform adds how to confirm; without it, "You have a call from {company}".
+     * English for now, whatever `language` says.
+     */
+    whisper?: string;
     /**
      * Background only: what is said as the two are put through. `person`: to the person, once they take
      * the call (`{{briefing}}` is the briefing; without it, the briefing). `customer`: to the customer, in
-     * their language (without it, a chime only).
+     * their language (66: per language; without it, a chime only).
      */
     bridge?: {
         person?: string;
-        customer?: string;
+        customer?: Spoken;
     };
+    /**
+     * The language of the person taking the call (BCP-47; default `en`), not the customer's (48 §10.3): what
+     * is said to them (the briefing, the waiting line) is said and written in it, and they are heard in it.
+     */
+    language?: string;
+    /** The run key (`runKey`): two transfers on a page apart; without it, `transfer`. */
+    key?: string;
     label?: string;
     description?: string;
 };
@@ -602,29 +687,35 @@ export type KeypadAction = {
     channel: 'keypad';
     /** The run key: `tried(ctx.runs, key)` after the first try. */
     key: string;
-    /** Said once, verbatim, before waiting for a key. */
-    say: string;
+    /** Said once, verbatim, before waiting for a key, in the call's language (66). */
+    say: Spoken;
     /** The keys that count. */
     digits: string[];
     timeoutMs: number;
     /** Where the key goes: a slot read from db. */
     write?: SlotRef;
-    /** Pressed key → value written (`{ '1': 'english', '2': 'spanish' }`); without it the key itself. */
+    /** Pressed key → value written (`{ '1': 'en', '2': 'es' }`); without it the key itself. */
     map?: Record<string, string | number | boolean>;
     label?: string;
     description?: string;
 };
-/** Say a fixed text, verbatim and not interruptible (a compliance statement). */
+/**
+ * Say a fixed text, verbatim and not interruptible (a compliance statement), in the call's language (66).
+ * After it, the model answers what the customer said; `answers`: the text is that answer (an opening line
+ * for a "Hello?", 65 §3.2), and nothing more is said after it.
+ */
 export type AnnounceAction = {
     $action: 'channel';
     channel: 'announce';
     key: string;
-    text: string;
+    text: Spoken;
+    answers?: true;
 };
 /** End the conversation (a call hangs up once the last line has played; an SMS conversation closes). */
 export type EndAction = {
     $action: 'channel';
-    channel: 'end';
+    channel: 'end'; /** The run key; without it, `end`. */
+    key?: string;
     label?: string;
     description?: string;
 };
@@ -634,8 +725,9 @@ export type EndAction = {
  */
 export type VoicemailAction = {
     $action: 'channel';
-    channel: 'voicemail';
-    text: string;
+    channel: 'voicemail'; /** Per language (66). */
+    text: Spoken; /** The run key; without it, `voicemail`. */
+    key?: string;
     label?: string;
     description?: string;
 };
@@ -646,14 +738,16 @@ export declare function transferTo(options: {
     callerId?: TransferAction['callerId'];
     mode?: TransferAction['mode'];
     briefing?: string;
+    whisper?: string;
     bridge?: TransferAction['bridge'];
+    language?: string;
     label?: string;
     description?: string;
 }): TransferAction;
 /** Whether a transfer's `to` is a SIP URI rather than a phone number. */
 export declare function isSipUri(to: string): boolean;
-export declare function keypad(key: string, options: {
-    say: string;
+export declare function keypadAction(key: string, options: {
+    say: Spoken;
     digits: string[];
     timeoutMs?: number;
     write?: Slot | SlotRef;
@@ -665,36 +759,21 @@ export declare function keypad(key: string, options: {
 export declare function runFunction(name: string, options?: {
     label?: string;
     description?: string;
-    say?: string;
+    say?: Spoken;
     parameters?: ActionParameters;
     prefill?: Record<string, unknown>;
 }): FunctionAction;
-export declare function announce(key: string, text: string): AnnounceAction;
-export declare function voicemail(text: string, options?: {
+export declare function announceAction(key: string, text: Spoken, options?: {
+    answers?: boolean;
+}): AnnounceAction;
+export declare function voicemailAction(text: Spoken, options?: {
     label?: string;
     description?: string;
 }): VoicemailAction;
-export declare function end(options?: {
+export declare function endAction(options?: {
     label?: string;
     description?: string;
 }): EndAction;
-/**
- * An action the page function returns to run now, with its run key (default: the action's name, a
- * channel action's key or kind) and whether the conversation waits for it (`wait: false`: run in the
- * background, the conversation goes on; not for channel actions).
- */
-export type PerformAction = {
-    $perform: true;
-    action: PageAction;
-    key?: string;
-    wait?: boolean;
-};
-export declare function perform(action: PageAction | {
-    toJSON(): PageAction;
-}, options?: {
-    key?: string;
-    wait?: boolean;
-}): PerformAction;
 /** Every channel a page may be written for, in order. */
 export declare const PAGE_CHANNELS: readonly PageChannel[];
 /** A page function: the page for one channel, or an action to run now (17b §9.1, §9.8). */
@@ -740,66 +819,53 @@ export declare function checkPageStart(raw: unknown): PageStart;
  * (`options: [{ id, label }]`, or `choose(rows, label)`); read-only, `options` only labels the current
  * value. Its definition is always on the page. `field()` refuses a ref field.
  */
-export declare function refField<S extends Slot>(slot: S, options?: RefFieldOptions): RefFieldCell<S>;
-export declare function field<S extends Slot>(slot: S, options?: FieldOptions): FieldCell<S>;
-/** A parameter taken from the schema: `schemaField('providers.name')`, `schemaField('injuries.id')` (a row). */
-export declare function schemaField(path: string, options?: SchemaFieldOptions): SchemaFieldParam;
+export declare function refFieldCell<S extends Slot>(slot: S, options?: RefFieldOptions): RefFieldCell<S>;
+export declare function fieldCell<S extends Slot>(slot: S, options?: FieldOptions): FieldCell<S>;
 /**
  * An action placed on a page: call it to prefill parameters (`addProvider({ injury: i.id })`), or place
- * it as it is (nothing prefilled). It crosses out of the sandbox as its JSON (`toJSON`).
+ * it as it is (nothing prefilled).
  */
-export type Placeable<A extends PageAction, P> = ((prefill?: P) => A) & {
-    toJSON(): A;
-};
+export type Placeable<A extends PageAction, P> = (prefill?: P) => A;
 /** Add a row (15 §10.6): `fields` are what the AI fills; call it to preset the rest (`({ status: 'active' })`). */
-export declare function createRow(table: TableReader | string, options: {
+export declare function createRowAction(table: TableReader | string, options: {
     fields: readonly string[];
     required?: readonly string[];
     label?: string;
     description?: string;
 }): Placeable<CreateRowAction, Record<string, unknown>>;
 /** Delete a row (cascading, 15 §10.6.1): a built-in action with the row prefilled and nothing to fill. */
-export declare function deleteRow(row: PageRow | string, options?: {
+export declare function deleteRowAction(row: PageRow | string, options?: {
     reason?: string;
     label?: string;
     description?: string;
 }): DeleteRowAction;
-type ActionRun<A> = (args: A, ctx: ActionContext) => unknown;
-export type DefinedAction<A> = Placeable<CustomAction, {
-    [K in keyof A]?: A[K] | ChooseParam;
-}> & {
-    readonly actionName: string;
-    readonly run: ActionRun<A>;
+/** The environment's configuration on a page (76 §2.19), read only. */
+export type PageEnv = {
+    get<T = unknown>(key: string): T | null;
 };
-/**
- * A custom action, declared like an LLM function call: `parameters` are everything `run` takes. Where
- * the page places it, some parameters may be prefilled; the AI fills the rest.
- */
-export declare function defineAction<A = Record<string, unknown>>(definition: {
-    name: string;
-    description: string;
-    parameters?: ActionParameters;
-    run: ActionRun<A>;
-}): DefinedAction<A>;
 export type PageEntryArg = {
     /** `start`: `persona` and `faq` once, when the conversation starts (24 §4), with the same context. */
     mode: 'render' | 'start';
     /** The page function to run; outside a conversation, the first one the page defines. */
     channel: PageChannel | null;
     subject: string;
+    /** The instance this conversation is on (38 §2.2: a function that needs it is prefilled it). */
+    instanceId: string;
     caller: PageRow | null;
     session: PageRow | null;
     conversation: PageConversation | null;
     runs: PageRuns;
     scheduledAction: PageScheduledAction | null;
     officeHours: PageContext['officeHours'];
-    followUps: PageFollowUp[];
+    nextSteps?: PageNextStep[];
     now: string;
     /** The contact's time zone and today there (25 §11). */
     time?: {
         zone: string;
         today: string;
     };
+    /** The environment's configuration (76 §2.19): its `env` integrations' values by key, as functions read them. */
+    env?: Record<string, unknown>;
     /** What the customer sent since the last run (20 §5.2): a text run's texts, an email run's emails. */
     sms?: {
         inbound: PageSmsMessage[];
@@ -811,6 +877,8 @@ export type PageEntryArg = {
     call?: {
         previous: PagePreviousCall | null;
         farEnd?: PageFarEnd | null;
+        heard?: PageHeard | null;
+        phase?: PageCallPhase;
     };
 }
 /** The channels with a page function: read once, when the sequence is compiled. */
@@ -828,7 +896,9 @@ export type PageEntryArg = {
 };
 /** No runs yet. */
 export declare function emptyRuns(): PageRuns;
-/** What the compiled page script evaluates to: renders the page, or runs one of its actions. */
-export declare function pageEntry(mod: Record<string, unknown>): (arg: PageEntryArg) => unknown;
-export {};
+/**
+ * What the compiled page script evaluates to: renders the page, or runs one of its actions. `actionsModule`
+ * is the sequence's `actions.ts` (76 §2.11), null without one.
+ */
+export declare function pageEntry(mod: Record<string, unknown>, actionsModule?: Record<string, unknown> | null): (arg: PageEntryArg) => unknown;
 //# sourceMappingURL=define.d.ts.map