@north-light/crouter 0.3.191 → 0.3.193

package/dist/pages/entry.d.ts

@@ -0,0 +1,8 @@
+import './bundle.css';
+import './elements/options.js';
+import './elements/text.js';
+import './elements/table.js';
+import './elements/cards.js';
+import './elements/chart.js';
+import './elements/pages.js';
+import './elements/slot.js';

package/dist/pages/entry.js

@@ -0,0 +1,8 @@
+import './bundle.css';
+import './elements/options.js';
+import './elements/text.js';
+import './elements/table.js';
+import './elements/cards.js';
+import './elements/chart.js';
+import './elements/pages.js';
+import './elements/slot.js';

package/dist/pages/host.d.ts

@@ -0,0 +1,132 @@
+/**
+ * `window.crtr` — the one door out of a page.
+ *
+ * An element renders inside a host (Northlight's srcdoc host today, a crtrd-served
+ * page later) that installs this bridge before the bundle loads. Everything an element
+ * needs from the outside world arrives through it: there is no `fetch`, no `XMLHttpRequest`,
+ * no direct network access anywhere under `src/pages/`. An element that cannot get what it
+ * needs renders a named unavailable state; it never falls back to reaching out itself.
+ *
+ * Two things the bridge deliberately does NOT have:
+ *
+ *  - **No `save` and no `dismiss`.** Both are host chrome — a frame around the page, not
+ *    markup inside it — so they are the host's own UI actions and are never advertised to
+ *    page code.
+ *  - **No per-element resolution.** `respond()` is a local-state write plus a request that
+ *    the host autosave the partial map; it does not resolve the ticket. Only the pager's
+ *    submit affordance calls `submit()`, which posts the complete map once.
+ *
+ * The host is optional at the type level (`window.crtr?`) because a page can be opened
+ * bare — dropped in a browser, or rendered by a host that installs nothing. Elements read
+ * the bridge through the accessors below rather than touching `window.crtr` directly, so
+ * that absence is typed and total instead of an `as any` at each call site.
+ */
+import type { SlotResponse } from './types.js';
+/** Live host theme tokens, as `--crtr-*` custom-property names mapped to values. */
+export interface CrtrThemeBridge {
+    current(): Record<string, string>;
+    /** Registers `listener` for later theme changes; returns its unsubscribe. */
+    subscribe(listener: (tokens: Record<string, string>) => void): () => void;
+}
+/** Data behind a `source`-bearing config (table, cards, chart). */
+export interface CrtrArtifactBridge {
+    /** Resolves the already-parsed data for `source`, or rejects when it is unreachable. */
+    data(source: string): Promise<unknown>;
+}
+/** What `mountWorkspaceComponent` can answer: the host rendered it, or it has no renderer. */
+export type WorkspaceMountOutcome = 'mounted' | 'unavailable';
+/** The bridge a host installs at `window.crtr`. */
+export interface CrtrHost {
+    /**
+     * Records this slot's complete current response and asks the host to autosave the
+     * partial map. Called on every user change. NOT ticket resolution.
+     */
+    respond(slotId: string, response: SlotResponse): void;
+    /** Posts the complete response map once. Only the pager's submit affordance calls it. */
+    submit(): Promise<void>;
+    /** Flushes the pending autosave of the partial map. */
+    progress(): Promise<void>;
+    readonly theme: CrtrThemeBridge;
+    readonly artifact: CrtrArtifactBridge;
+    /**
+     * Asks the host to render a product-registered (`unvalidated`) slot into `element`.
+     * A host with no renderer for `kind` answers `'unavailable'`.
+     */
+    mountWorkspaceComponent(element: HTMLElement, kind: string, config: Record<string, unknown>): Promise<WorkspaceMountOutcome>;
+}
+declare global {
+    interface Window {
+        /**
+         * Installed by the host before the bundle loads. Optional: a page opened bare has
+         * no bridge, and every element must still render.
+         */
+        crtr?: CrtrHost;
+    }
+}
+/**
+ * The outcome of a bridge call. `unavailable` means the door is not there — no host, or a
+ * host that does not implement this method. `failed` means the host was asked and said no,
+ * and `reason` is what it said. Elements distinguish them because "this page is not hosted"
+ * and "the server rejected your answer" are different things to show a person.
+ */
+export type HostCall = {
+    status: 'ok';
+} | {
+    status: 'unavailable';
+    reason: string;
+} | {
+    status: 'failed';
+    reason: string;
+};
+/** The outcome of an artifact read, with the same three-way split as `HostCall`. */
+export type ArtifactData = {
+    status: 'ok';
+    data: unknown;
+} | {
+    status: 'unavailable';
+    reason: string;
+} | {
+    status: 'failed';
+    reason: string;
+};
+/** The installed bridge, or `undefined` on a bare page. */
+export declare function host(): CrtrHost | undefined;
+/**
+ * Writes this slot's complete current response to the host's in-frame map and requests an
+ * autosave. Elements call this on every user change with the whole response object, never a
+ * delta. Safe on a bare page: the element's own local state is authoritative for rendering,
+ * so an unavailable host only means the answer is not being persisted.
+ */
+export declare function respond(slotId: string, response: SlotResponse): HostCall;
+/**
+ * Posts the complete response map once, resolving the ticket. Only the pager's submit
+ * affordance calls this.
+ */
+export declare function submit(): Promise<HostCall>;
+/** Flushes the host's pending autosave of the partial map. Never resolves the ticket. */
+export declare function progress(): Promise<HostCall>;
+/**
+ * The host's current theme token values. Empty on a bare page — which is correct and needs
+ * no handling, because `bundle.css` declares every `--crtr-*` token at zero specificity and
+ * elements style through those custom properties rather than through this map. Read it only
+ * when a value must reach somewhere CSS cannot, such as an SVG attribute.
+ */
+export declare function themeTokens(): Record<string, string>;
+/**
+ * Subscribes to later theme changes. Always returns an unsubscribe, so a caller can wire it
+ * to `disconnectedCallback` without checking whether a host was there.
+ */
+export declare function subscribeTheme(listener: (tokens: Record<string, string>) => void): () => void;
+/**
+ * Reads the data behind a `source`-bearing config. The host resolves the reference and hands
+ * back parsed data; an element never resolves a reference itself and never fetches a URL.
+ * Anything other than `'ok'` is a named unavailable state to render, not a reason to retry
+ * some other way.
+ */
+export declare function artifactData(source: string): Promise<ArtifactData>;
+/**
+ * Asks the host to render a product-registered slot into `element`. A bare page, a host with
+ * no registry, and a host whose mount threw all answer `'unavailable'` — the escape element's
+ * named unavailable state is the only other outcome.
+ */
+export declare function mountWorkspaceComponent(element: HTMLElement, kind: string, config: Record<string, unknown>): Promise<WorkspaceMountOutcome>;

package/dist/pages/host.js

@@ -0,0 +1,149 @@
+/**
+ * `window.crtr` — the one door out of a page.
+ *
+ * An element renders inside a host (Northlight's srcdoc host today, a crtrd-served
+ * page later) that installs this bridge before the bundle loads. Everything an element
+ * needs from the outside world arrives through it: there is no `fetch`, no `XMLHttpRequest`,
+ * no direct network access anywhere under `src/pages/`. An element that cannot get what it
+ * needs renders a named unavailable state; it never falls back to reaching out itself.
+ *
+ * Two things the bridge deliberately does NOT have:
+ *
+ *  - **No `save` and no `dismiss`.** Both are host chrome — a frame around the page, not
+ *    markup inside it — so they are the host's own UI actions and are never advertised to
+ *    page code.
+ *  - **No per-element resolution.** `respond()` is a local-state write plus a request that
+ *    the host autosave the partial map; it does not resolve the ticket. Only the pager's
+ *    submit affordance calls `submit()`, which posts the complete map once.
+ *
+ * The host is optional at the type level (`window.crtr?`) because a page can be opened
+ * bare — dropped in a browser, or rendered by a host that installs nothing. Elements read
+ * the bridge through the accessors below rather than touching `window.crtr` directly, so
+ * that absence is typed and total instead of an `as any` at each call site.
+ */
+/** The installed bridge, or `undefined` on a bare page. */
+export function host() {
+    return typeof window === 'undefined' ? undefined : window.crtr;
+}
+function reasonOf(error) {
+    if (error instanceof Error && error.message !== '')
+        return error.message;
+    const text = String(error);
+    return text === '' ? 'unknown error' : text;
+}
+function missing(method) {
+    return { status: 'unavailable', reason: `host bridge does not provide ${method}()` };
+}
+/**
+ * Writes this slot's complete current response to the host's in-frame map and requests an
+ * autosave. Elements call this on every user change with the whole response object, never a
+ * delta. Safe on a bare page: the element's own local state is authoritative for rendering,
+ * so an unavailable host only means the answer is not being persisted.
+ */
+export function respond(slotId, response) {
+    const bridge = host();
+    if (typeof bridge?.respond !== 'function')
+        return missing('respond');
+    try {
+        bridge.respond(slotId, response);
+        return { status: 'ok' };
+    }
+    catch (error) {
+        return { status: 'failed', reason: reasonOf(error) };
+    }
+}
+/**
+ * Posts the complete response map once, resolving the ticket. Only the pager's submit
+ * affordance calls this.
+ */
+export async function submit() {
+    const bridge = host();
+    if (typeof bridge?.submit !== 'function')
+        return missing('submit');
+    try {
+        await bridge.submit();
+        return { status: 'ok' };
+    }
+    catch (error) {
+        return { status: 'failed', reason: reasonOf(error) };
+    }
+}
+/** Flushes the host's pending autosave of the partial map. Never resolves the ticket. */
+export async function progress() {
+    const bridge = host();
+    if (typeof bridge?.progress !== 'function')
+        return missing('progress');
+    try {
+        await bridge.progress();
+        return { status: 'ok' };
+    }
+    catch (error) {
+        return { status: 'failed', reason: reasonOf(error) };
+    }
+}
+/**
+ * The host's current theme token values. Empty on a bare page — which is correct and needs
+ * no handling, because `bundle.css` declares every `--crtr-*` token at zero specificity and
+ * elements style through those custom properties rather than through this map. Read it only
+ * when a value must reach somewhere CSS cannot, such as an SVG attribute.
+ */
+export function themeTokens() {
+    const bridge = host();
+    if (typeof bridge?.theme?.current !== 'function')
+        return {};
+    try {
+        return bridge.theme.current();
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Subscribes to later theme changes. Always returns an unsubscribe, so a caller can wire it
+ * to `disconnectedCallback` without checking whether a host was there.
+ */
+export function subscribeTheme(listener) {
+    const bridge = host();
+    if (typeof bridge?.theme?.subscribe !== 'function')
+        return () => { };
+    try {
+        const unsubscribe = bridge.theme.subscribe(listener);
+        return typeof unsubscribe === 'function' ? unsubscribe : () => { };
+    }
+    catch {
+        return () => { };
+    }
+}
+/**
+ * Reads the data behind a `source`-bearing config. The host resolves the reference and hands
+ * back parsed data; an element never resolves a reference itself and never fetches a URL.
+ * Anything other than `'ok'` is a named unavailable state to render, not a reason to retry
+ * some other way.
+ */
+export async function artifactData(source) {
+    const bridge = host();
+    if (typeof bridge?.artifact?.data !== 'function')
+        return missing('artifact.data');
+    try {
+        return { status: 'ok', data: await bridge.artifact.data(source) };
+    }
+    catch (error) {
+        return { status: 'failed', reason: reasonOf(error) };
+    }
+}
+/**
+ * Asks the host to render a product-registered slot into `element`. A bare page, a host with
+ * no registry, and a host whose mount threw all answer `'unavailable'` — the escape element's
+ * named unavailable state is the only other outcome.
+ */
+export async function mountWorkspaceComponent(element, kind, config) {
+    const bridge = host();
+    if (typeof bridge?.mountWorkspaceComponent !== 'function')
+        return 'unavailable';
+    try {
+        return await bridge.mountWorkspaceComponent(element, kind, config);
+    }
+    catch {
+        return 'unavailable';
+    }
+}

package/dist/pages/register.d.ts

@@ -0,0 +1,2 @@
+export type CrtrElementName = `crtr-${string}`;
+export declare function registerElement(name: CrtrElementName, element: CustomElementConstructor): void;

package/dist/pages/register.js

@@ -0,0 +1,3 @@
+export function registerElement(name, element) {
+    customElements.define(name, element);
+}

package/dist/pages/slot-config.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Reading a slot's config out of the DOM.
+ *
+ * The host renders each slot as
+ * `<crtr-KIND slot-id="ID"><script type="application/json">CONFIG_JSON</script></crtr-KIND>`,
+ * and every element does the same three things in `connectedCallback`: find that script child,
+ * parse it, and render a named error state instead of throwing when it is missing or malformed.
+ * That is one behaviour, so it lives here once.
+ *
+ * **What is and is not checked.** The JSON's *shape* was already validated by
+ * `validatePageManifest` before the manifest was stored, and the renderer emits from that
+ * validated manifest — so an element may trust the parsed object against its own config type.
+ * What is not guaranteed is that the script child is there at all and that its text parses: a
+ * page can be hand-written, truncated, or rendered by something else. Those two failures are
+ * what this module reports.
+ */
+/** A parsed config, or the reason the element should render an error state instead. */
+export type SlotConfigResult<T> = {
+    status: 'ok';
+    config: T;
+} | {
+    status: 'invalid';
+    reason: string;
+};
+/**
+ * Reads and parses the JSON script child of `element`.
+ *
+ * `T` is the element's own mirrored config type and is asserted, not verified — see the note
+ * above on why that is sound. Never throws.
+ */
+export declare function readSlotConfig<T = Record<string, unknown>>(element: HTMLElement): SlotConfigResult<T>;
+/**
+ * The slot id the host addressed this element by — the key `respond()` takes. Absent on a
+ * display-only slot, which has no id and produces no response.
+ */
+export declare function readSlotId(element: HTMLElement): string | undefined;

package/dist/pages/slot-config.js

@@ -0,0 +1,50 @@
+/**
+ * Reading a slot's config out of the DOM.
+ *
+ * The host renders each slot as
+ * `<crtr-KIND slot-id="ID"><script type="application/json">CONFIG_JSON</script></crtr-KIND>`,
+ * and every element does the same three things in `connectedCallback`: find that script child,
+ * parse it, and render a named error state instead of throwing when it is missing or malformed.
+ * That is one behaviour, so it lives here once.
+ *
+ * **What is and is not checked.** The JSON's *shape* was already validated by
+ * `validatePageManifest` before the manifest was stored, and the renderer emits from that
+ * validated manifest — so an element may trust the parsed object against its own config type.
+ * What is not guaranteed is that the script child is there at all and that its text parses: a
+ * page can be hand-written, truncated, or rendered by something else. Those two failures are
+ * what this module reports.
+ */
+/**
+ * Reads and parses the JSON script child of `element`.
+ *
+ * `T` is the element's own mirrored config type and is asserted, not verified — see the note
+ * above on why that is sound. Never throws.
+ */
+export function readSlotConfig(element) {
+    const script = element.querySelector('script[type="application/json"]');
+    if (script === null)
+        return { status: 'invalid', reason: 'slot has no application/json config' };
+    const text = script.textContent ?? '';
+    if (text.trim() === '')
+        return { status: 'invalid', reason: 'slot config is empty' };
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        const detail = error instanceof Error && error.message !== '' ? error.message : 'invalid JSON';
+        return { status: 'invalid', reason: `slot config is not valid JSON: ${detail}` };
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return { status: 'invalid', reason: 'slot config must be a JSON object' };
+    }
+    return { status: 'ok', config: parsed };
+}
+/**
+ * The slot id the host addressed this element by — the key `respond()` takes. Absent on a
+ * display-only slot, which has no id and produces no response.
+ */
+export function readSlotId(element) {
+    const id = element.getAttribute('slot-id')?.trim();
+    return id === undefined || id === '' ? undefined : id;
+}

package/dist/pages/types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * The response contract the page bundle produces, as plain browser-safe types.
+ *
+ * These mirror `src/core/human/page-schema.ts` field-for-field — `commentSchema`,
+ * `commentAnchorSchema`, and the four `*ResponseSchema`s — and are deliberately a
+ * separate declaration rather than an import: nothing under `src/pages/` may reach
+ * a runtime package (zod) or a module outside this directory, because the bundle is
+ * a browser IIFE. The schemas remain the source of truth; a change there is a change
+ * that must land here in the same commit.
+ *
+ * Two rules the shapes are built around:
+ *
+ *  1. **One comment shape everywhere.** Every response-bearing element carries
+ *     comments, and every comment is `{ id, anchor, text }`. A comment on an option,
+ *     a table row, a card, or a range of prose differs only in its `anchor`.
+ *  2. **Selection is ids, never indexes or values.** The agent authored the ids it is
+ *     asking about, so the response keys straight off them.
+ *
+ * Config types are NOT here: a config is one element's private input, mirrored in that
+ * element's own module. A response is what crosses `window.crtr.respond`, so it is
+ * shared.
+ */
+/** What a comment is attached to. One union across every element. */
+export type CommentAnchor = 
+/** The presented content as a whole. */
+{
+    kind: 'whole';
+}
+/** One option of an `options` element. */
+ | {
+    kind: 'option';
+    optionId: string;
+}
+/** One row of a `table`. */
+ | {
+    kind: 'row';
+    rowId: string;
+}
+/** One column of a `table`. */
+ | {
+    kind: 'column';
+    columnId: string;
+}
+/** One card of a `cards` grid. */
+ | {
+    kind: 'card';
+    cardId: string;
+}
+/**
+ * A character range of a `text` element's final text, review-style. `quote` is the
+ * text as it read when the comment was left, so the comment survives (readably) an
+ * edit that moves the offsets.
+ */
+ | {
+    kind: 'range';
+    start: number;
+    end: number;
+    quote: string;
+};
+/** A user comment. The same shape in every element's response. */
+export type Comment = {
+    /** Stable per comment; frame-local, minted by `newCommentId()`. */
+    id: string;
+    anchor: CommentAnchor;
+    text: string;
+};
+/** `options` — single or multi select, per-option comments, optional freetext. */
+export type OptionsResponse = {
+    /** Always an array; a single-select answer is a one-element array. */
+    selectedOptionIds: string[];
+    comments: Comment[];
+    /** Present only when the config allows freetext and the user typed something. */
+    freetext?: string;
+};
+/** `text` — an edited draft and/or anchored comments on presented prose. */
+export type TextResponse = {
+    /** The text as the user is leaving it. */
+    text: string;
+    /** True once `text` differs from what the agent presented. */
+    edited: boolean;
+    comments: Comment[];
+};
+/** `table` — row and/or column selection with anchored comments. */
+export type TableResponse = {
+    selectedRowIds: string[];
+    selectedColumnIds: string[];
+    comments: Comment[];
+};
+/** `cards` — card selection with per-card comments. */
+export type CardsResponse = {
+    selectedCardIds: string[];
+    comments: Comment[];
+};
+/**
+ * Any slot response. The open member covers a product-registered `unvalidated` slot,
+ * whose shape only the product renderer knows.
+ */
+export type SlotResponse = OptionsResponse | TextResponse | TableResponse | CardsResponse | Record<string, unknown>;

package/dist/pages/types.js

@@ -0,0 +1,23 @@
+/**
+ * The response contract the page bundle produces, as plain browser-safe types.
+ *
+ * These mirror `src/core/human/page-schema.ts` field-for-field — `commentSchema`,
+ * `commentAnchorSchema`, and the four `*ResponseSchema`s — and are deliberately a
+ * separate declaration rather than an import: nothing under `src/pages/` may reach
+ * a runtime package (zod) or a module outside this directory, because the bundle is
+ * a browser IIFE. The schemas remain the source of truth; a change there is a change
+ * that must land here in the same commit.
+ *
+ * Two rules the shapes are built around:
+ *
+ *  1. **One comment shape everywhere.** Every response-bearing element carries
+ *     comments, and every comment is `{ id, anchor, text }`. A comment on an option,
+ *     a table row, a card, or a range of prose differs only in its `anchor`.
+ *  2. **Selection is ids, never indexes or values.** The agent authored the ids it is
+ *     asking about, so the response keys straight off them.
+ *
+ * Config types are NOT here: a config is one element's private input, mirrored in that
+ * element's own module. A response is what crosses `window.crtr.respond`, so it is
+ * shared.
+ */
+export {};

package/dist/pi-extensions/__tests__/canvas-structured-output.test.js

@@ -1,6 +1,6 @@
 // Run with: node --import tsx/esm --test src/pi-extensions/__tests__/canvas-structured-output.test.ts
 //
-// Regression: Codex strict function schemas require every property in `required`.
+// Regression: strict function schemas require all properties and closed object shapes.
 import { after, test } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync } from 'node:fs';
@@ -37,9 +37,15 @@ test('optional submit fields remain optional through a strict provider tool sche
             commit: { type: 'string' },
             verification: { type: 'string' },
             blocker: { type: 'string' },
+            details: {
+                type: 'object',
+                properties: {
+                    summary: { type: 'string' },
+                },
+                required: ['summary'],
+            },
         },
-        required: ['status', 'verification'],
-        additionalProperties: false,
+        required: ['status', 'verification', 'details'],
     };
     writeOutputSchema('structured-output-test', 'oneoff', schema);
     let definition;
@@ -51,10 +57,12 @@ test('optional submit fields remain optional through a strict provider tool sche
     });
     assert.ok(definition, 'the pending request registers submit');
     const parameters = definition['parameters'];
-    assert.deepEqual(parameters.required, ['status', 'commit', 'verification', 'blocker']);
+    assert.deepEqual(parameters.required, ['status', 'commit', 'verification', 'blocker', 'details']);
     assert.deepEqual(parameters.properties.commit, { anyOf: [{ type: 'string' }, { type: 'null' }] });
     assert.deepEqual(parameters.properties.blocker, { anyOf: [{ type: 'string' }, { type: 'null' }] });
-    assert.deepEqual(schema.required, ['status', 'verification'], 'the stored request keeps its original optionality');
+    assert.equal(parameters.additionalProperties, false);
+    assert.equal(parameters.properties.details.additionalProperties, false);
+    assert.deepEqual(schema.required, ['status', 'verification', 'details'], 'the stored request keeps its original optionality');
     const [providerTool] = convertResponsesTools([definition], {
         strict: false,
         supportsStrictMode: true,

package/dist/pi-extensions/canvas-structured-output.js

@@ -47,6 +47,10 @@ function strictToolSchema(schema) {
             }
         }
         const properties = transformed['properties'];
+        const isObjectSchema = transformed['type'] === 'object'
+            || (properties !== null && typeof properties === 'object' && !Array.isArray(properties));
+        if (isObjectSchema)
+            transformed['additionalProperties'] = false;
         if (properties === null || typeof properties !== 'object' || Array.isArray(properties))
             return transformed;
         const required = new Set(Array.isArray(source['required']) ? source['required'].filter((name) => typeof name === 'string') : []);
@@ -125,9 +129,9 @@ export function registerCanvasStructuredOutput(pi) {
                         'Use submit to answer the pending one-off structured-output request before stopping or going dormant.',
                         'After one-off submit succeeds, continue with any remaining work normally.',
                     ],
-                // OpenAI strict tools require every property to be required. Optional fields
-                // become nullable in the provider-only schema and null is removed before the
-                // original result is persisted.
+                // Strict provider tools require every property to be required and every
+                // object to reject undeclared properties. Optional fields become nullable
+                // in the provider-only schema and null is removed before persistence.
                 parameters: strictToolSchema(request.schema),
                 constrainedSampling: { type: 'json_schema', strict: 'prefer' },
                 async execute(_toolCallId, params, _signal, _onUpdate, ctx) {

package/dist/types.d.ts

@@ -185,6 +185,10 @@ export interface ScopeConfig {
     /** Play the whip header animation whenever the human sends a prompt, and once
      *  when an automatically opened managed-child viewer starts. Default false. */
     whip_mode: boolean;
+    /** Teach agent help the HTML page-authoring dialect. Off keeps page authoring Markdown-only. */
+    html_pages: boolean;
+    /** Product-registered page slot kinds beyond crtr's built-in catalog. */
+    page_components: string[];
     /** Playful urgency messages the attach-viewer whip action sends to an agent. Missing, malformed, or empty lists fall back to the built-in rotation. */
     whip_messages: string[];
     /** Initial mouse wheel scrolling mode for each attach viewer. `tmux` follows

package/dist/types.js

@@ -78,6 +78,8 @@ export function defaultScopeConfig() {
         completion_bell: true,
         working_gerunds: [...DEFAULT_WORKING_GERUNDS],
         whip_mode: false,
+        html_pages: false,
+        page_components: [],
         whip_messages: [...DEFAULT_WHIP_MESSAGES],
         mouse_mode_default: 'tmux',
         live_cycles: DEFAULT_LIVE_CYCLES,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.191",
+  "version": "0.3.193",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",
@@ -86,9 +86,9 @@
     "test:seam": "npm run build && node --test --test-concurrency=1 --test-timeout=180000 'dist/**/__tests__/seam/*.test.js'"
   },
   "overrides": {
-    "@earendil-works/pi-ai": "0.83.0",
-    "@earendil-works/pi-agent-core": "0.83.0",
-    "@earendil-works/pi-tui": "0.83.0"
+    "@earendil-works/pi-ai": "0.84.1",
+    "@earendil-works/pi-agent-core": "0.84.1",
+    "@earendil-works/pi-tui": "0.84.1"
   },
   "repository": {
     "type": "git",
@@ -99,10 +99,10 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@earendil-works/pi-agent-core": "0.83.0",
-    "@earendil-works/pi-ai": "0.83.0",
-    "@earendil-works/pi-coding-agent": "0.83.0",
-    "@earendil-works/pi-tui": "0.83.0",
+    "@earendil-works/pi-agent-core": "0.84.1",
+    "@earendil-works/pi-ai": "0.84.1",
+    "@earendil-works/pi-coding-agent": "0.84.1",
+    "@earendil-works/pi-tui": "0.84.1",
     "cron-parser": "^5.6.0",
     "proper-lockfile": "4.1.2",
     "string-width": "^7.0.0",