@genesislcap/ai-assistant 15.61.0 → 15.62.0

package/dist/esm/state/decision-surface.js

@@ -0,0 +1,209 @@
+/** The `select` action a multi-select adds. Platform-owned, so never an option's id. */
+export const SELECT_ACTION = 'select';
+/** The `reply` action `freeText` adds. Platform-owned, so never an option's id. */
+export const REPLY_ACTION = 'reply';
+const normalise = (option) => {
+    var _a;
+    return typeof option === 'string'
+        ? { id: option, label: option }
+        : { id: (_a = option.id) !== null && _a !== void 0 ? _a : option.label, label: option.label, enabledWhen: option.enabledWhen };
+};
+const isEnabled = (option) => {
+    var _a, _b;
+    try {
+        return (_b = (_a = option.enabledWhen) === null || _a === void 0 ? void 0 : _a.call(option)) !== null && _b !== void 0 ? _b : true;
+    }
+    catch (_c) {
+        // A guard that throws cannot vouch for its button.
+        return false;
+    }
+};
+/**
+ * Build the surface for a short-form decision (GENC-1660). Its actions are its options (by id),
+ * plus `select` for a multi-select and `reply` for a written answer; all of them finish. Every
+ * read — facts, actions, enabled-ness — is taken fresh, so the surface always describes the
+ * widget as it is now.
+ *
+ * Throws if an option's id collides with another or with a platform-owned name, which is a bug in
+ * the widget rather than something to recover from.
+ */
+export function buildDecisionSurface(spec) {
+    const options = spec.options.map(normalise);
+    const ids = new Set();
+    for (const { id } of options) {
+        if (ids.has(id))
+            throw new Error(`exposeDecision: two options share the id "${id}".`);
+        if ((spec.multi && id === SELECT_ACTION) || (spec.freeText && id === REPLY_ACTION)) {
+            throw new Error(`exposeDecision: an option cannot use the reserved id "${id}".`);
+        }
+        ids.add(id);
+    }
+    const byIdOrLabel = (key) => typeof key === 'string' ? options.find((o) => o.id === key || o.label === key) : undefined;
+    const actions = () => {
+        const enabled = options.filter(isEnabled);
+        return [
+            ...options.map((o) => ({
+                name: o.id,
+                label: o.label,
+                finishes: true,
+                enabled: isEnabled(o),
+            })),
+            ...(spec.multi
+                ? [
+                    {
+                        name: SELECT_ACTION,
+                        finishes: true,
+                        enabled: enabled.length > 0,
+                        args: 'options',
+                    },
+                ]
+                : []),
+            ...(spec.freeText
+                ? [{ name: REPLY_ACTION, finishes: true, enabled: true, args: 'text' }]
+                : []),
+        ];
+    };
+    const answer = (a) => () => spec.choose(a);
+    return {
+        prompt: spec.prompt,
+        facts: () => { var _a, _b; return (_b = (_a = spec.facts) === null || _a === void 0 ? void 0 : _a.call(spec)) !== null && _b !== void 0 ? _b : {}; },
+        actions,
+        isReady: () => actions().some((a) => a.finishes && a.enabled),
+        prepare(name, args) {
+            if (spec.multi && name === SELECT_ACTION) {
+                const picked = args === null || args === void 0 ? void 0 : args.options;
+                if (!Array.isArray(picked) || picked.length === 0) {
+                    return {
+                        error: 'invalid-args',
+                        message: '`select` takes { options: string[] }, not empty.',
+                    };
+                }
+                const chosen = picked.map(byIdOrLabel);
+                const unknown = picked.filter((_, i) => !chosen[i]);
+                if (unknown.length) {
+                    return { error: 'invalid-args', message: `Not options here: ${unknown.join(', ')}.` };
+                }
+                const disabled = chosen.filter((o) => !isEnabled(o));
+                if (disabled.length) {
+                    return {
+                        error: 'disabled',
+                        message: `Not available right now: ${disabled.map((o) => o.label).join(', ')}.`,
+                    };
+                }
+                const picks = chosen;
+                return {
+                    choice: picks.map((o) => o.label).join(', '),
+                    finishes: true,
+                    run: answer({ kind: 'options', options: picks.map((o) => o.id) }),
+                };
+            }
+            if (spec.freeText && name === REPLY_ACTION) {
+                const text = args === null || args === void 0 ? void 0 : args.text;
+                if (typeof text !== 'string' || !text.trim()) {
+                    return { error: 'invalid-args', message: '`reply` takes { text: string }, not empty.' };
+                }
+                return { choice: text, finishes: true, run: answer({ kind: 'text', text }) };
+            }
+            const option = options.find((o) => o.id === name);
+            if (!option) {
+                return { error: 'unknown-action', message: `No action "${name}" here.` };
+            }
+            if (!isEnabled(option)) {
+                return { error: 'disabled', message: `"${option.label}" is not available right now.` };
+            }
+            return {
+                choice: option.label,
+                finishes: true,
+                run: answer({ kind: 'option', option: option.id }),
+            };
+        },
+    };
+}
+/** How long a choice's text may run in a `decidedOnUsersBehalf` record, in characters. */
+const CHOICE_CHARS = 300;
+/** The JSON types a schema's `type` names, as `typeof` reads them. */
+const matchesType = (value, type) => {
+    switch (type) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+        case 'integer':
+            return typeof value === 'number' && (type === 'number' || Number.isInteger(value));
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'array':
+            return Array.isArray(value);
+        case 'object':
+            return !!value && typeof value === 'object' && !Array.isArray(value);
+        default:
+            return true;
+    }
+};
+/**
+ * Check `args` against an action's schema: an object, with its `required` properties present and
+ * each listed property of its declared top-level `type`. Deliberately shallow — enough to refuse a
+ * malformed call with a reason the model can act on, without a schema library in the browser.
+ */
+export function checkArgs(args, schema) {
+    var _a, _b;
+    if (!schema)
+        return undefined;
+    if (!matchesType(args, 'object'))
+        return 'its arguments must be an object.';
+    const record = args;
+    const required = (_a = schema.required) !== null && _a !== void 0 ? _a : [];
+    const missing = required.filter((key) => record[key] === undefined);
+    if (missing.length)
+        return `missing: ${missing.join(', ')}.`;
+    const properties = ((_b = schema.properties) !== null && _b !== void 0 ? _b : {});
+    const wrong = Object.entries(properties)
+        .filter(([key, prop]) => record[key] !== undefined && !matchesType(record[key], prop === null || prop === void 0 ? void 0 : prop.type))
+        .map(([key, prop]) => `${key} should be ${String(prop === null || prop === void 0 ? void 0 : prop.type)}`);
+    return wrong.length ? `${wrong.join('; ')}.` : undefined;
+}
+/**
+ * Build the surface for a full-form spec (GENC-1660 §4.2): named actions, some editing and some
+ * finishing, each guarded and schema-checked; a description; views to read. Every read is fresh.
+ */
+export function buildFullSurface(spec) {
+    const guard = (enabledWhen) => {
+        var _a;
+        try {
+            return (_a = enabledWhen === null || enabledWhen === void 0 ? void 0 : enabledWhen()) !== null && _a !== void 0 ? _a : true;
+        }
+        catch (_b) {
+            return false;
+        }
+    };
+    const actions = () => Object.entries(spec.actions).map(([name, a]) => (Object.assign({ name, finishes: !!a.finishes, enabled: guard(a.enabledWhen), description: a.description }, (a.argsSchema ? { args: 'fields', argsSchema: a.argsSchema } : {}))));
+    return {
+        prompt: spec.prompt,
+        facts: () => ({}),
+        describe: () => spec.describe(),
+        views: spec.views,
+        read: (view) => spec.read(view),
+        actions,
+        isReady: () => actions().some((a) => a.enabled),
+        prepare(name, args) {
+            // Own actions only: a name from the model such as `constructor` or `toString` must not reach
+            // the object's prototype.
+            const action = Object.prototype.hasOwnProperty.call(spec.actions, name)
+                ? spec.actions[name]
+                : undefined;
+            if (!action)
+                return { error: 'unknown-action', message: `No action "${name}" here.` };
+            if (!guard(action.enabledWhen)) {
+                return { error: 'disabled', message: `"${name}" is not available right now.` };
+            }
+            const problem = checkArgs(args !== null && args !== void 0 ? args : {}, action.argsSchema);
+            if (problem)
+                return { error: 'invalid-args', message: `"${name}": ${problem}` };
+            const shown = args && Object.keys(args).length ? ` ${JSON.stringify(args)}` : '';
+            return {
+                choice: `${name}${shown}`.slice(0, CHOICE_CHARS),
+                finishes: !!action.finishes,
+                run: () => action.run(args !== null && args !== void 0 ? args : {}),
+            };
+        },
+    };
+}

package/dist/esm/state/interaction-context.js

@@ -1,4 +1,5 @@
 import { logger } from '../utils/logger';
+import { buildDecisionSurface, buildFullSurface } from './decision-surface';
 /**
  * Create a live, per-interaction context (GENC-1390). Framework-agnostic: the
  * `subscribe`/`notify` pair is a plain observer set, not FAST reactivity. See
@@ -6,18 +7,58 @@ import { logger } from '../utils/logger';
  *
  * @internal
  */
-export function createInteractionContext(interactionId) {
+export function createInteractionContext(interactionId, deps = {}) {
     const state = {};
     const onceCache = new Map();
     const listeners = new Set();
     const disposers = new Set();
+    const readyListeners = new Set();
     let disposed = false;
+    let settled = false;
     let heldBy = 'user';
+    let controller;
+    let surface;
+    let lastActivityAt = Date.now();
+    let checkpoint = deps.checkpoint;
+    /** Fire every waiting `onSurfaceReady` once the surface has something a claimant could do. */
+    const checkReady = () => {
+        if (disposed || !surface || readyListeners.size === 0 || !surface.isReady())
+            return;
+        const waiting = [...readyListeners];
+        readyListeners.clear();
+        for (const fn of waiting) {
+            try {
+                fn();
+            }
+            catch (e) {
+                logger.error('InteractionContext onSurfaceReady callback threw', e);
+            }
+        }
+    };
     const context = {
         interactionId,
         get heldBy() {
             return heldBy;
         },
+        get controller() {
+            return controller;
+        },
+        get surface() {
+            return surface;
+        },
+        get lastActivityAt() {
+            return lastActivityAt;
+        },
+        get checkpoint() {
+            return checkpoint;
+        },
+        saveCheckpoint(next) {
+            var _a;
+            if (disposed)
+                return;
+            checkpoint = next;
+            (_a = deps.saveCheckpoint) === null || _a === void 0 ? void 0 : _a.call(deps, next);
+        },
         state,
         once(key, factory) {
             if (onceCache.has(key))
@@ -35,6 +76,8 @@ export function createInteractionContext(interactionId) {
             return value;
         },
         notify() {
+            // Every notification is a heartbeat: the controller is still doing something (GENC-1660).
+            lastActivityAt = Date.now();
             // A Set tolerates a listener unsubscribing mid-walk (matches
             // interaction-panel-session's forEach); a throwing subscriber must not stop the rest.
             for (const listener of listeners) {
@@ -45,6 +88,8 @@ export function createInteractionContext(interactionId) {
                     logger.error('InteractionContext subscriber threw during notify()', e);
                 }
             }
+            // A guard that turned true is a gate that just opened.
+            checkReady();
         },
         subscribe(listener) {
             listeners.add(listener);
@@ -61,6 +106,42 @@ export function createInteractionContext(interactionId) {
             }
             disposers.add(fn);
         },
+        resolve(result) {
+            var _a;
+            if (settled || disposed)
+                return;
+            settled = true;
+            (_a = deps.resolve) === null || _a === void 0 ? void 0 : _a.call(deps, result);
+        },
+        exposeDecision(decision) {
+            if (disposed)
+                return;
+            surface = buildDecisionSurface(decision);
+            context.notify();
+        },
+        exposeSurface(spec) {
+            if (disposed)
+                return;
+            surface = buildFullSurface(spec);
+            context.notify();
+        },
+        onSurfaceReady(fn) {
+            if (disposed)
+                return () => undefined;
+            if (surface === null || surface === void 0 ? void 0 : surface.isReady()) {
+                fn();
+                return () => undefined;
+            }
+            readyListeners.add(fn);
+            return () => {
+                readyListeners.delete(fn);
+            };
+        },
+        claimantOwns(action) {
+            if (heldBy === 'user' || !surface)
+                return false;
+            return surface.actions().some((a) => a.name === action && a.enabled);
+        },
     };
     return {
         context,
@@ -78,6 +159,7 @@ export function createInteractionContext(interactionId) {
             }
             disposers.clear();
             listeners.clear();
+            readyListeners.clear();
             // Release memoised `once` values (sockets, timers, service handles) for GC — the resources
             // themselves are closed via their `onDispose`, but drop the references too.
             onceCache.clear();
@@ -89,5 +171,11 @@ export function createInteractionContext(interactionId) {
             context.notify();
             return true;
         },
+        setController(value) {
+            controller = value;
+        },
+        get surface() {
+            return surface;
+        },
     };
 }

package/dist/esm/state/interaction-registry.js

@@ -0,0 +1,33 @@
+import { logger } from '../utils/logger';
+const registry = new Map();
+/**
+ * Register a widget with the platform (GENC-1660): its controller, the element that renders it, how
+ * it behaves while a claimant holds it, and its text form. Once per name, at start-up; a second
+ * registration under the same name replaces the first, with a warning.
+ *
+ * Registering is optional and additive: an unregistered widget works exactly as before.
+ *
+ * @beta
+ */
+export function registerInteraction(name, registration) {
+    if (registry.has(name)) {
+        logger.warn(`registerInteraction: "${name}" was already registered; replacing it.`);
+    }
+    registry.set(name, registration);
+}
+/**
+ * The registration for a component name, or `undefined` when it has none.
+ *
+ * @beta
+ */
+export function getInteractionRegistration(name) {
+    return registry.get(name);
+}
+/**
+ * Forget every registration. For tests.
+ *
+ * @internal
+ */
+export function clearInteractionRegistry() {
+    registry.clear();
+}

package/dist/esm/state/persistence/session-persister.js

@@ -7,6 +7,9 @@ import { recordMetaEvent } from '../debug-event-log';
 import { diagnosticsMessageKey } from './diagnostics';
 import { getDiagnosticsCursors } from './diagnostics-cursors';
 import { buildResumeNote, createPersistedSession, isRestorableSession, keepThroughLastUserMessage, reconcileAgentSnapshots, resolveNonResumableNotice, toLoadSessionPayload, trimToRestorableBoundary, unknownAgentSnapshots, } from './session-snapshot';
+const autopilotOf = (driver) => driver && typeof driver.getPersistedMode === 'function'
+    ? driver
+    : undefined;
 /**
  * Backstop for a slow/hung persistence provider on startup restore (GENC-1351
  * §6). Deliberately long: silently losing a restorable session is a far worse
@@ -293,7 +296,7 @@ export class SessionPersister {
      */
     persistSession() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
             const { provider, enabled } = this.deps.getPersistence();
             if (!enabled || !provider)
                 return;
@@ -453,6 +456,8 @@ export class SessionPersister {
                 activeProviderName: s.activeProviderName,
                 agentSnapshots,
                 condensePolicies: this.condensePoliciesToPersist(driver, messages),
+                autopilot: (_h = autopilotOf(driver)) === null || _h === void 0 ? void 0 : _h.getPersistedMode(),
+                checkpoint: (_j = driver === null || driver === void 0 ? void 0 : driver.getInteractionCheckpoint) === null || _j === void 0 ? void 0 : _j.call(driver),
             });
             // Observability (GENC-1351): record what each autosave captured for stateful
             // agents — `agents: []` here means no machine snapshot was taken (the bug to
@@ -468,7 +473,7 @@ export class SessionPersister {
             const captured = {
                 messages: messages.length,
                 agents: Object.keys(agentSnapshots),
-                active: (_h = liveActive === null || liveActive === void 0 ? void 0 : liveActive.name) !== null && _h !== void 0 ? _h : null,
+                active: (_k = liveActive === null || liveActive === void 0 ? void 0 : liveActive.name) !== null && _k !== void 0 ? _k : null,
                 hasSerialize: !!(liveActive === null || liveActive === void 0 ? void 0 : liveActive.serialize),
                 agentSnapshots,
             };
@@ -487,7 +492,7 @@ export class SessionPersister {
                 // means the body never reached the wire at all, because a provider builds its
                 // request body inside the `fetch` init, so a throw while serialising creates no
                 // request and leaves no server-side trace.
-                this.recordSaveOutcome(false, (_j = e === null || e === void 0 ? void 0 : e.message) !== null && _j !== void 0 ? _j : String(e));
+                this.recordSaveOutcome(false, (_l = e === null || e === void 0 ? void 0 : e.message) !== null && _l !== void 0 ? _l : String(e));
                 // Report straight away rather than waiting for the next attempt: we are on the resumable
                 // path, so a reload is safe NOW, and a one-cycle delay is a second of extra exposure for
                 // no benefit.
@@ -504,8 +509,8 @@ export class SessionPersister {
                     agents: captured.agents,
                     active: captured.active,
                     hasSerialize: captured.hasSerialize,
-                    error: (_k = e === null || e === void 0 ? void 0 : e.name) !== null && _k !== void 0 ? _k : typeof e,
-                    message: (_l = e === null || e === void 0 ? void 0 : e.message) !== null && _l !== void 0 ? _l : String(e),
+                    error: (_m = e === null || e === void 0 ? void 0 : e.name) !== null && _m !== void 0 ? _m : typeof e,
+                    message: (_o = e === null || e === void 0 ? void 0 : e.message) !== null && _o !== void 0 ? _o : String(e),
                 });
                 logger.error('Session save failed:', e);
             }
@@ -524,7 +529,7 @@ export class SessionPersister {
      */
     restore() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
             const { provider } = this.deps.getPersistence();
             if (!provider)
                 return undefined;
@@ -582,6 +587,13 @@ export class SessionPersister {
                 // matter when the agent re-activates. The flow-owner lock self-heals on
                 // activation (OrchestratingDriver.installAgent re-sets it).
                 driver === null || driver === void 0 ? void 0 : driver.primeRestoredAgentState(snapshot.agentSnapshots);
+                // The autopilot's mode waits for its flow to re-activate; restoring it starts nothing.
+                (_d = autopilotOf(driver)) === null || _d === void 0 ? void 0 : _d.restorePersistedMode(snapshot.autopilot);
+                // A long action the reload cut waits for the next request of its widget type (§4.12) — but
+                // only when its flow is re-activated above. A flow left behind (interrupted, or an owner this
+                // driver does not know) never ends, so nothing would clear its checkpoint, and the next request
+                // of that widget type would take over the abandoned run's work.
+                (_e = driver === null || driver === void 0 ? void 0 : driver.restoreInteractionCheckpoint) === null || _e === void 0 ? void 0 : _e.call(driver, flowOwner ? snapshot.checkpoint : undefined);
                 // Seed the carry-forward cache so the immediate post-restore autosave (fired
                 // by the history change below, before any agent re-activates) preserves the
                 // machine snapshot instead of overwriting it with an empty one (GENC-1351).
@@ -653,14 +665,14 @@ export class SessionPersister {
                 }
                 const messages = [...trimmed, ...trailers];
                 ref.actions.aiAssistant.loadSession(toLoadSessionPayload(Object.assign(Object.assign({}, snapshot), { messages })));
-                (_d = driver === null || driver === void 0 ? void 0 : driver.loadHistory) === null || _d === void 0 ? void 0 : _d.call(driver, [...messages]);
+                (_f = driver === null || driver === void 0 ? void 0 : driver.loadHistory) === null || _f === void 0 ? void 0 : _f.call(driver, [...messages]);
                 // Re-arm the condense policies that had not fired at save time (GENC-1632) — AFTER
                 // `loadHistory`, because the driver keeps only entries whose tool call is in the history it
                 // now holds, which is how an entry for a call `trimToRestorableBoundary` cut away is dropped
                 // rather than resurrected. A snapshot from before the field existed has none, so this is a
                 // no-op and the restore is exactly what it was. Timing against the agent's re-activation is
                 // the driver's problem, not ours: it defers the activation stamp to the next `installAgent`.
-                const condenseRestore = (_e = driver === null || driver === void 0 ? void 0 : driver.restoreCondensePolicies) === null || _e === void 0 ? void 0 : _e.call(driver, snapshot.condensePolicies);
+                const condenseRestore = (_g = driver === null || driver === void 0 ? void 0 : driver.restoreCondensePolicies) === null || _g === void 0 ? void 0 : _g.call(driver, snapshot.condensePolicies);
                 // Observability (GENC-1351, counts refined for GENC-1632 review): record exactly what the
                 // restore primed, so a post-reload debug-log export shows whether a stateful agent's snapshot
                 // actually came back (meta events reset on reload, so this is the only window onto the
@@ -672,7 +684,7 @@ export class SessionPersister {
                 // are left OFF the object (not zeroed) when there is no driver or it predates this method, so
                 // that case can't be misread as "re-armed none" either.
                 this.logMeta('persistence.restored', {
-                    agents: Object.keys((_f = snapshot.agentSnapshots) !== null && _f !== void 0 ? _f : {}),
+                    agents: Object.keys((_h = snapshot.agentSnapshots) !== null && _h !== void 0 ? _h : {}),
                     condensePolicies: Object.assign({ stored: Array.isArray(snapshot.condensePolicies) ? snapshot.condensePolicies.length : 0 }, condenseRestore),
                     agentSnapshots: snapshot.agentSnapshots,
                     pinnedAgentName: snapshot.pinnedAgentName,
@@ -701,8 +713,8 @@ export class SessionPersister {
                 //
                 // On the driver itself, not a narrowed orchestrator (GENC-1660): both members are on
                 // `AiDriver` and every decorator forwards them, so this reaches the routing whatever wraps it.
-                driver === null || driver === void 0 ? void 0 : driver.setPinnedAgent((_g = snapshot.pinnedAgentName) !== null && _g !== void 0 ? _g : null);
-                driver === null || driver === void 0 ? void 0 : driver.setFlowOwner((_h = snapshot.flowOwnerAgentName) !== null && _h !== void 0 ? _h : null);
+                driver === null || driver === void 0 ? void 0 : driver.setPinnedAgent((_j = snapshot.pinnedAgentName) !== null && _j !== void 0 ? _j : null);
+                driver === null || driver === void 0 ? void 0 : driver.setFlowOwner((_k = snapshot.flowOwnerAgentName) !== null && _k !== void 0 ? _k : null);
                 if (flowOwner) {
                     this.logMeta('persistence.resume-planned', {
                         flowOwner,

package/dist/esm/state/persistence/session-snapshot.js

@@ -14,7 +14,7 @@ export const PERSISTED_SESSION_VERSION = 1;
  */
 export function createPersistedSession(input) {
     var _a, _b;
-    return Object.assign({ version: PERSISTED_SESSION_VERSION, savedAt: new Date().toISOString(), host: input.host, sessionKey: input.sessionKey, messages: input.messages, activeAgentName: input.activeAgentName, pinnedAgentName: input.pinnedAgentName, flowOwnerAgentName: input.flowOwnerAgentName, sessionCostUsd: input.sessionCostUsd, contextTokens: input.contextTokens, contextLimit: input.contextLimit, activeModel: input.activeModel, activeProviderName: input.activeProviderName, agentSnapshots: (_a = input.agentSnapshots) !== null && _a !== void 0 ? _a : {} }, (((_b = input.condensePolicies) === null || _b === void 0 ? void 0 : _b.length) ? { condensePolicies: input.condensePolicies } : {}));
+    return Object.assign(Object.assign(Object.assign({ version: PERSISTED_SESSION_VERSION, savedAt: new Date().toISOString(), host: input.host, sessionKey: input.sessionKey, messages: input.messages, activeAgentName: input.activeAgentName, pinnedAgentName: input.pinnedAgentName, flowOwnerAgentName: input.flowOwnerAgentName, sessionCostUsd: input.sessionCostUsd, contextTokens: input.contextTokens, contextLimit: input.contextLimit, activeModel: input.activeModel, activeProviderName: input.activeProviderName, agentSnapshots: (_a = input.agentSnapshots) !== null && _a !== void 0 ? _a : {} }, (((_b = input.condensePolicies) === null || _b === void 0 ? void 0 : _b.length) ? { condensePolicies: input.condensePolicies } : {})), (input.autopilot ? { autopilot: input.autopilot } : {})), (input.checkpoint ? { checkpoint: input.checkpoint } : {}));
 }
 /**
  * Resolve the notice text + pre-fill prompt for an interrupted (non-resumable) flow

package/dist/esm/state/run-steps.js

@@ -0,0 +1,77 @@
+import { __awaiter } from "tslib";
+const recorders = new WeakMap();
+/**
+ * Bind the debug-log recorders for a context's steps: each step's outcome, and a handed-over
+ * checkpoint refused as malformed. Called by the platform when it creates the context, so
+ * `runSteps` records under the right session without the context carrying it.
+ *
+ * @internal
+ */
+export function bindStepRecorder(ctx, record, refused) {
+    recorders.set(ctx, { step: record, refused });
+}
+/**
+ * The checkpoint to start from: the one handed over when it is shaped like one, otherwise a fresh
+ * one from `initial`. A handed-over checkpoint is persisted data — saved by an older version of the
+ * widget, say, or read from a damaged store — so it is checked rather than trusted: a malformed one
+ * would otherwise throw on the first step and leave the interaction parked with nothing to settle it.
+ */
+function startingPoint(handed, initial, refused) {
+    const fresh = () => (Object.assign(Object.assign({}, initial), { done: [] }));
+    if (handed === undefined)
+        return fresh();
+    const started = handed === null || handed === void 0 ? void 0 : handed.started;
+    if (!Array.isArray(handed === null || handed === void 0 ? void 0 : handed.done) || (started !== undefined && !Array.isArray(started))) {
+        refused === null || refused === void 0 ? void 0 : refused('malformed: no list of done steps', handed);
+        return fresh();
+    }
+    return handed;
+}
+/**
+ * Run a long action as named steps, checkpointing after each one (GENC-1660 §4.12), so a reload
+ * skips what is already done instead of starting again.
+ *
+ * Starts from the checkpoint the platform handed over, if any — it has already decided, by widget
+ * type and the registration's `sameWork`, that the checkpoint is this work's — or from `initial`, the
+ * identity `sameWork` compares, kept in the checkpoint because the request that cut it is gone.
+ * Each step that is already done is skipped; the rest run in order. `ctx.state.stage` names the step
+ * running, and every step notifies, which is also the watchdog's heartbeat.
+ *
+ * Exported beside the context rather than added to it, so the context's own API stays small.
+ * Throws if `signal` aborts, before or between steps.
+ *
+ * @beta
+ */
+export function runSteps(ctx, initial, steps, signal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const { step: record, refused } = (_a = recorders.get(ctx)) !== null && _a !== void 0 ? _a : {};
+        let cp = startingPoint(ctx.checkpoint, initial, refused);
+        const save = (next) => {
+            cp = next;
+            ctx.saveCheckpoint(cp);
+        };
+        for (const step of steps) {
+            signal === null || signal === void 0 ? void 0 : signal.throwIfAborted();
+            if (cp.done.includes(step.name)) {
+                record === null || record === void 0 ? void 0 : record(step.name, 'skipped');
+                continue;
+            }
+            // Started before the reload but never finished: it runs again, with whatever it saved part-way.
+            const resumed = !!((_b = cp.started) === null || _b === void 0 ? void 0 : _b.includes(step.name));
+            record === null || record === void 0 ? void 0 : record(step.name, resumed ? 'resumed' : 'started');
+            if (!resumed)
+                save(Object.assign(Object.assign({}, cp), { started: [...((_c = cp.started) !== null && _c !== void 0 ? _c : []), step.name] }));
+            ctx.state.stage = step.name;
+            ctx.notify();
+            // oxlint-disable-next-line no-await-in-loop -- steps run in order: each may need the last's output
+            const out = yield step.run(cp, {
+                signal,
+                save: (partial) => save(Object.assign(Object.assign({}, cp), partial)),
+            });
+            save(Object.assign(Object.assign(Object.assign({}, cp), out), { done: [...cp.done, step.name] }));
+            record === null || record === void 0 ? void 0 : record(step.name, 'done');
+        }
+        return cp;
+    });
+}

package/dist/esm/types/interaction-surface.js

@@ -0,0 +1 @@
+export {};