sygnal 6.2.0 → 6.4.0

package/src/extra/ai/compose/render.ts

@@ -0,0 +1,159 @@
+/*
+ * PLAN-9 K-2: catalog.render(slice, state, { scope?, frozen?, answer?, at? }), the composition as
+ * vnodes for the host's own view (phase1-contract.md). It renders `slice.preview ?? slice.layout`.
+ *
+ * - A part is a component vnode, so every composed part is a child instance of the host (CHILD.select,
+ *   lenses, EVENTS, context and drivers work as for any child). It gets:
+ *   - its identity: `key` = `scope/nodeKey` (or `nodeKey`); the core keys instances by the vnode key
+ *     (D470: `key ?? props.id ?? path`), so params, including one named `id`, reach the part as props;
+ *   - its state: `state: 'key'` as is, a lens as is, `(node, key) => lens` called, `local: init` a lens
+ *     into `slice.local[nodeKey]` (at the slice's path `at`); each lens is memoized per node (G-752),
+ *     so a part re-renders only when its own state, props or params change;
+ *   - its params, defaults filled, as props (or `props(params, state)`; an object `props` is merged
+ *     under them), and the props `node` (its key), and `scope` / `frozen` / `answer` when given (a
+ *     result part's answer: `answer.value` when `answer.node` is its key).
+ *   A part declared with `render` (a view function) is called inline with the same props and
+ *   `state` read through its lens.
+ * - A container calls its view with `{ key, node, params (defaults filled), slots, children, ui, control, scope, frozen }`:
+ *   `slots` maps each slot to its vnodes, `children` lists `{ key, node, part, slot, vnode }` in
+ *   order, `ui` is `slice.ui[key]`, and `control(name, value)` returns data attributes to spread on an
+ *   element; a click on it is the behavior's CONTROL `{ key, name, value }` (ui[key][name] = value).
+ * - A frozen render is wrapped in `<fieldset disabled class="compose-frozen">`.
+ * - A container view or `props()` that throws: only the composition is replaced (a `.compose-error`
+ *   element), SYG406. Under `<Composed>` (composed.ts) the throw goes on to the host's `onError`
+ *   instead, rendered in place of the composition (SYG408). An unknown part or slot is skipped (SYG250, once per catalog and name).
+ */
+import {createElement as h} from '../../../pragma/index'
+import {error as logError} from '../../diagnostics/legacy'
+import {dev} from './diag'
+import type {Catalog, Part, RenderOptions} from './types'
+
+const getIn = (o: any, path: any[]) => path.reduce((x, k) => x?.[k], o)
+const setIn = (o: any, path: any[], v: any): any => {
+  const [k, ...rest] = path
+  const base = Array.isArray(o) ? o.slice() : {...o}
+  base[k] = rest.length ? setIn(o?.[k] ?? {}, rest, v) : v
+  return base
+}
+
+/** the memoized lenses (G-752), per catalog: (at, scope, node key, part, params) → lens */
+const memo = /*#__PURE__*/ new WeakMap<object, Map<string, any>>()
+const MAX = 2000
+
+function lensOf(cat: Catalog, part: Part, node: any, key: string, at: any[] | null, scope?: string): any {
+  if (!part.hasLocal && typeof part.state != 'function') return part.state
+  let m = memo.get(cat)
+  if (!m) memo.set(cat, m = new Map())
+  const id = JSON.stringify([at, scope ?? null, key, part.id, part.hasLocal ? 0 : node.params ?? null])
+  let l = m.get(id)
+  if (l !== undefined) return l
+  if (part.hasLocal) {
+    const init = part.local, path = at ? [...at, 'local', key] : null
+    l = {
+      get: (st: any) => (path ? getIn(st, path) : undefined) ?? init,
+      set: (st: any, v: any) => (path ? setIn(st, path, v) : st),
+    }
+  } else l = (part.state as any)(node, key)
+  if (m.size > MAX) m.clear()
+  m.set(id, l)
+  return l
+}
+
+/** a part's params with the defaults filled in */
+function paramsOf(part: {params: Record<string, any>}, node: any): Record<string, any> {
+  const out: any = {}
+  for (const k in part.params) {
+    const v = node.params?.[k] ?? (part.params[k] as any).default
+    if (v !== undefined) out[k] = v
+  }
+  for (const k in node.params) if (!(k in out)) out[k] = node.params[k]
+  return out
+}
+
+/** the slice's path in the host state: `at`, else the host key whose value is the slice */
+function pathOf(slice: any, state: any, at: RenderOptions['at']): any[] | null {
+  if (Array.isArray(at)) return at
+  if (typeof at == 'string') return [at]
+  if (state && typeof state == 'object') for (const k in state) if (state[k] === slice) return [k]
+  return null
+}
+
+/** `contain` false (the `<Composed>` marker): a throw reaches the caller, which renders the host's onError (SYG408) */
+export function renderLayout(cat: Catalog, slice: any, state: any, opts: RenderOptions = {}, contain = true): any {
+  const layout = slice?.preview ?? slice?.layout
+  if (!layout || typeof layout != 'object' || !layout.nodes) return null
+  const {scope, frozen, answer} = opts
+  const at = pathOf(slice, state, opts.at), atStr = at ? at.join('.') : undefined
+  const nodes = layout.nodes, seen = new Set<string>()
+  const extra: any = {}
+  if (scope !== undefined) extra.scope = scope
+  if (frozen) extra.frozen = true
+
+  const nodeOf = (key: string): any => {
+    const n = nodes[key]
+    if (!n || seen.has(key)) return null
+    seen.add(key)
+    const e: any = cat.get(n.part)
+    if (!e) { dev('SYG250', 'catalog.render', `the layout names an unknown part '${n.part}' (node '${key}'); it is not rendered`, 'warn', cat, 'render:' + n.part); return null }
+    if (e.kind == 'container') {
+      const slots: Record<string, any[]> = {}, children: any[] = []
+      for (const s of e.slotNames) slots[s] = []
+      for (const s in n.slots) {
+        if (!slots[s]) { dev('SYG250', 'catalog.render', `node '${key}' (${e.id}) has no slot '${s}'; its children are not rendered`, 'warn', cat, `render:${e.id}:${s}`); continue }
+        for (const k of n.slots[s] || []) {
+          const vnode = nodeOf(k)
+          if (vnode == null) continue
+          slots[s].push(vnode)
+          children.push({key: k, node: nodes[k], part: cat.get(nodes[k].part), slot: s, vnode})
+        }
+      }
+      const control = (name: string, value?: any) => ({
+        'data-compose-control': name, 'data-compose-key': key, 'data-compose-value': JSON.stringify(value ?? null),
+        ...(atStr !== undefined && {'data-compose-at': atStr}), ...(scope !== undefined && {'data-compose-scope': scope}),
+      })
+      return e.render({key, node: n, params: paramsOf(e, n), slots, children, ui: slice.ui?.[key] || {}, control, scope, frozen: !!frozen})
+    }
+    const part = e as Part
+    // H-2: a result part answers a card (chat's askCard gives the call id as scope); elsewhere its answer reaches no one
+    if (part.result && scope === undefined) dev('SYG160', 'catalog.render', `the result part '${part.id}' is rendered outside a card (no scope), so its answer reaches no tool call`, 'warn', cat, 'result:' + part.id)
+    const params = paramsOf(part, n)
+    const props = typeof part.props == 'function' ? part.props(params, state) : {...part.props, ...params}
+    const lens = lensOf(cat, part, n, key, at, scope)
+    const own = {...props, ...extra, node: key, ...(answer && answer.node === key && {answer: answer.value})}
+    if (part.render) return part.render({...own, state: lens === undefined ? state : typeof lens == 'string' ? state?.[lens] : lens.get(state)})
+    if (!part.component) return null
+    const id = scope !== undefined ? `${scope}/${key}` : key
+    // identity from the vnode key (D470: key ?? props.id ?? path), so a param named `id` reaches the part
+    return h(part.component, {...own, ...(lens !== undefined && {state: lens}), key: id})
+  }
+
+  let out: any
+  try { out = nodeOf(layout.root || 'page') } catch (err) {
+    if (!contain) throw err
+    logError('SYG406', 'catalog.render', 'a container view or a part\'s props() threw; the composition is replaced by an empty .compose-error element', 'Check the container\'s render and the part\'s props for missing data', err)
+    return h('div', {className: 'compose-error'})
+  }
+  return frozen ? h('fieldset', {disabled: true, className: 'compose-frozen'}, out) : out
+}
+
+/**
+ * H-2: an `ask_user` tool part's card as `[slice, options]` for catalog.render (askCard and
+ * `<Composed card={part} />`): the call id as scope, frozen unless the card is open, the answer
+ * marked, `at` the part's `ui` in the chat `k` (so `local` parts write to it). Null without a layout.
+ */
+export function cardArgs(state: any, part: any, k = 'assistant'): [any, RenderOptions] | null {
+  const u = part?.ui
+  if (!u?.layout) return null
+  const msgs = state?.[k]?.messages || []
+  let at: any[] | undefined
+  for (let i = msgs.length - 1; i >= 0 && !at; i--) {
+    const j = (msgs[i].parts || []).findIndex((x: any) => x.toolCallId === part.toolCallId && x.ui)
+    if (j >= 0) at = [k, 'messages', i, 'parts', j, 'ui']
+  }
+  return [u, {
+    scope: part.toolCallId,
+    frozen: part.state !== 'input-available' || u.status !== 'open',
+    answer: u.answer ? {node: u.answer.node, value: u.answer.value} : null,
+    ...(at && {at}),
+  }]
+}

package/src/extra/ai/compose/testing.ts

@@ -0,0 +1,71 @@
+/*
+ * PLAN-9 T-1: composeWith(t, catalog, tree, { stream? }), a test fixture for a whole composition,
+ * the same for every backend:
+ *
+ *   t.simulateAction('page.COMPOSE', 'Revenue and churn side by side')
+ *   await composeWith(t, catalog, [{ part: 'row', children: [{ part: 'revenue' }, { part: 'churn' }] }])
+ *
+ * It finds the composition of `catalog` that is waiting for a reply (a `compose` use whose slice
+ * has `pending`) and answers each of its steps with the backend's `fake()` (the reply body that
+ * leads to `tree`) on the backend's sink, targeted by the use's reply action (`page.REPLY`):
+ * `t.respond`, or, with `stream: n` (true: 3) and a text body, `t.stream` in n chunks (an LLM
+ * backend's JSON). It resolves once no step is pending.
+ *
+ * H-2: a card of `chat({ ask: { catalog } })` being composed (an `ask_user` part whose `ui` has
+ * `pending`) is answered the same way, targeted by the chat's CARD action ('assistant.CARD'). A
+ * compose use waiting goes first.
+ */
+import {usesOf} from './behavior'
+import {cardsOf} from './ask'
+import type {Tree} from './types'
+
+const err = (m: string) => new Error(`[Sygnal] composeWith: ${m}`)
+
+/** a step waiting for a reply: its backend, the reply action, the pending step, and how to find the next one */
+type Cur = {backend: any; target: string; pending: any; next: () => Cur | undefined} | undefined
+
+export async function composeWith(t: any, catalog: any, tree: Tree, options: {stream?: number | boolean} = {}): Promise<void> {
+  const entries = usesOf(catalog), cards = cardsOf(catalog)
+  if (!entries.length && !cards.length) throw err('no compose behavior uses this catalog (compose(catalog, { backend }) in a component\'s uses, or chat({ ask: { catalog } }))')
+  const use = (e: (typeof entries)[number], k: string, s: any): Cur => ({backend: e.backend, target: k + '.REPLY', pending: s.pending, next: () => {
+    const n = t.state?.[k]
+    return n?.pending != null && n.pending !== s.pending ? use(e, k, n) : undefined
+  }})
+  // the card being composed in a chat's last message (cards compose one at a time)
+  const cardOf = (backend: any, k: string, id?: string): Cur => {
+    const msgs = t.state?.[k]?.messages, m = Array.isArray(msgs) ? msgs[msgs.length - 1] : null
+    const p = m?.role == 'assistant' && (m.parts || []).find((x: any) => x.ui?.status == 'composing' && x.ui.pending != null && x.state == 'input-available' && (id === undefined || x.toolCallId === id))
+    if (!p) return
+    return {backend, target: k + '.CARD', pending: p.ui.pending, next: () => { const n = cardOf(backend, k, p.toolCallId); return n && n.pending !== p.ui.pending ? n : undefined }}
+  }
+  // the use that made the pending step (several hosts may share the catalog and the key)
+  const find = (): Cur => {
+    let any: Cur
+    for (const e of entries) for (const k of e.keys) {
+      const s = t.state?.[k]
+      if (s?.pending == null) continue
+      if (typeof s.pending == 'object' && e.mine.has(s.pending)) return use(e, k, s)
+      any ||= use(e, k, s)
+    }
+    if (any) return any
+    for (const c of cards) for (const k of c.keys) {
+      const x = cardOf(c.backend, k)
+      if (x && c.mine.has(x.pending)) return x
+      any ||= x
+    }
+    return any
+  }
+  let cur: Cur = find()
+  if (!cur) { await t.settle(); cur = find() }
+  if (!cur) throw err('no composition is waiting for a reply (send COMPOSE first, or let the chat model call ask_user)')
+  for (let step = 0; cur && step < 16; step++) {
+    const {backend, target, pending} = cur
+    const sink: string = backend.sink
+    const body = backend.fake({catalog, state: t.state, pending, target: tree})
+    if (options.stream && typeof body == 'string') {
+      const n = Math.max(1, options.stream === true ? 3 : Number(options.stream) || 1), size = Math.ceil(body.length / n) || 1
+      for (let i = 0; i < n; i++) await t.stream(sink, [body.slice(i * size, (i + 1) * size)], target, {end: i == n - 1})
+    } else await t.respond(sink, body, target)
+    cur = cur.next()
+  }
+}

package/src/extra/ai/compose/types.ts

@@ -0,0 +1,159 @@
+/*
+ * PLAN-9 (phase1-contract.md): the internal shapes shared by the compose modules (catalog, layout,
+ * render, the behavior, the backends). Public, inferred types: src/ai.d.ts (`// ---- PLAN-9
+ * compose`). Type-only: this module emits nothing.
+ */
+
+/**
+ * a param declaration, normalized: the canonical form every module reads (layout's checks, render,
+ * both backends). `kind` replaces the declaration's discriminator (`options` → 'options',
+ * `type: 'number' | 'text' | 'list'` → that kind (`type` itself is not kept), `from` → 'record');
+ * only the fields listed here are kept. An options param always has a `default` (its first option when none is
+ * given); `required` is a boolean on text and list params.
+ *
+ *   options: { kind: 'options', options: { value: description }, default, label?, ask? }
+ *   number:  { kind: 'number', min?, max?, default?, bins?: { number: description }, label? }
+ *   text:    { kind: 'text', maxLength?, default?, required, label? }
+ *   list:    { kind: 'list', items?: { maxLength? }, min?, max?, required, default?, label? }
+ *   record:  { kind: 'record', from: (state) => [{ value, name?, aliases?, description? }], label? }
+ */
+export type Param =
+  | {kind: 'options'; options: Record<string, string>; default?: any; label?: string; ask?: string}
+  | {kind: 'number'; min?: number; max?: number; default?: number; bins?: Record<string, string>; label?: string}
+  | {kind: 'text'; maxLength?: number; default?: string; required?: boolean; label?: string}
+  | {kind: 'list'; items?: {maxLength?: number}; min?: number; max?: number; required?: boolean; default?: string[]; label?: string}
+  | {kind: 'record'; from: (state: any) => any[]; label?: string; default?: undefined}
+
+/** a catalog part, normalized */
+export interface Part {
+  id: string
+  kind: 'part'
+  component?: any
+  render?: (props: any) => any
+  props?: Record<string, any> | ((params: Record<string, any>, state: any) => Record<string, any>)
+  description: string
+  state?: string | {get: Function; set?: Function} | ((node: Node, key: string) => any)
+  /** `local: init`: state kept at slice.local[nodeKey] */
+  local?: any
+  hasLocal: boolean
+  params: Record<string, Param>
+  /** the record param's name (at most one per part) */
+  record?: string
+  /** the places it may go: 'container:slot' entries (the root is 'page:default') */
+  in: string[]
+  group?: string
+  maxUses: number
+  required: boolean
+  pin?: 'start' | 'end'
+  companions: string[]
+  category?: string
+  result: boolean
+  /** everything the declaration had, for backends that read extra fields */
+  decl: Record<string, any>
+}
+
+/** a catalog container (a view function with named slots), normalized */
+export interface Container {
+  id: string
+  kind: 'container'
+  slots: Record<string, string | null>
+  slotNames: string[]
+  minSlots?: number
+  /** children per slot: fewer than `min` unwraps it, more than `max` overflow (a row splits) */
+  min?: number
+  max?: number
+  /** 'leaves': only parts in its slots (nested containers go after it) */
+  accepts?: 'leaves'
+  params: Record<string, Param>
+  arranged: boolean
+  direction?: 'row' | 'column'
+  description?: string
+  render: (a: any) => any
+  /** where the container itself may go ('container:slot' entries) */
+  in: string[]
+  decl: Record<string, any>
+}
+
+export type Entry = Part | Container
+
+/** one node of a layout */
+export interface Node {
+  part: string
+  params?: Record<string, any>
+  slots?: Record<string, string[]>
+}
+
+/** the layout: a node map with identity keys */
+export interface Layout {
+  root: 'page'
+  nodes: Record<string, Node>
+}
+
+/** the nested form a model writes and tests use */
+export type TreeNode = {part: string; params?: Record<string, any>; children?: Tree | Record<string, Tree>}
+export type Tree = TreeNode[]
+
+export interface Option {option: string; part: string; params?: Record<string, any>; description: string}
+
+export interface Catalog {
+  parts: Record<string, Part>
+  containers: Record<string, Container>
+  get(id: string): Entry | undefined
+  options(state: any): Option[]
+  /** a record part's records (validated `from`: SYG252) */
+  records(part: Part | string, state: any): Array<{value: any; name?: string; aliases?: string[]; description?: string}>
+  finish(layout: Layout, state?: any): Layout
+  /** the page's label (B: `containers.page.description ?? catalog.description`) */
+  description?: string
+  categories: Record<string, string>
+  /** false: the catalog opted out of the built-in row */
+  rows: boolean
+  guidance?: string
+  /**
+   * maxParts: leaves on the page (finish drops the last non-required ones). maxDepth: how deep a
+   * CONTAINER may sit, counting the page as 0 and its children as 1: a container at depth d > maxDepth
+   * moves to the page (finish; structure/composer.mjs's rule). Both backends follow it: decisions'
+   * reading, and llm's schema and repair (a container is offered at depth d only when d <= maxDepth).
+   * Leaves may sit one level below the deepest container. (The research llm-composer.mjs counted
+   * leaves instead: its maxDepth m is this one's m - 1.)
+   */
+  limits: {maxParts: number; maxDepth: number}
+  examples: any[]
+  render(slice: any, state: any, opts?: RenderOptions): any
+}
+
+export interface RenderOptions {
+  scope?: string
+  frozen?: boolean
+  answer?: {node: string; value: any} | null
+  /** the slice's path in the host state (default: found by identity among the host's keys) */
+  at?: string | Array<string | number>
+}
+
+/** the reply action names a backend's requests carry */
+export interface Names {ok: string; error: string; delta: string; key: string}
+
+/** a composition backend (phase1-contract.md: A defines it, B and C implement it) */
+export interface Backend {
+  sink: string
+  start(a: {catalog: Catalog; state: any; prompt: string; previous: Layout | null; names: Names}): {request: any; pending: any}
+  reply(a: {catalog: Catalog; state: any; pending: any; reply: any; names: Names}):
+    {layout?: Layout | null; unavailable?: true; preview?: Layout; request?: any; pending?: any; decisions?: unknown; error?: string; keyed?: boolean}
+  delta?(a: {catalog: Catalog; state: any; pending: any; delta: any}): {preview?: Layout; keyed?: boolean}
+  fake(a: {catalog: Catalog; state: any; pending: any; target: Tree}): unknown
+}
+
+export type Status = 'idle' | 'composing' | 'preview' | 'done' | 'unavailable' | 'error'
+
+/** the compose behavior's slice */
+export interface ComposeSlice {
+  prompt: string
+  status: Status
+  layout: Layout | null
+  preview: Layout | null
+  pending: any
+  decisions: unknown
+  error: string | null
+  ui: Record<string, Record<string, any>>
+  local: Record<string, any>
+}

package/src/extra/ai/decide.ts

@@ -44,6 +44,102 @@ function dictionary({url = '/api/decide', model, state, questions, images, ...re
   return {url, method: 'POST', json, ...rest};
 }
 
+// ---------- D472 / G-757: large question sets ----------
+/**
+ * A conservative estimate of the prompt tokens of a request's question (Ollama /v1/systemone: each
+ * question's prompt holds the state and EVERY question of the request, instructions and options).
+ * Measured on nimble over compose.decisions()'s requests: 1.13–1.30 × the count Ollama reports
+ * (ASCII ~2.6 characters a token; any other character counted as one).
+ */
+const tokensOf = (x: any) => {
+  const t = text(x ?? '');
+  let other = 0;
+  for (let i = 0; i < t.length; i++) if (t.charCodeAt(i) > 127) other++;
+  return (t.length - other) / 2.5 + other;
+};
+const questionTokens = (name: string, q: any) => {
+  const c = q?.criteria, opts: any[] = Array.isArray(c) ? c.map(x => [x, null]) : Object.entries(c && typeof c == 'object' ? c : {});
+  return 12 + 4 * opts.length + tokensOf(name) + tokensOf(q?.instructions) + opts.reduce((n, [k, v]) => n + tokensOf(k) + (v == null ? 0 : tokensOf(v)), 0);
+};
+/** the estimated prompt tokens of one question of a request with this state and these questions */
+export const promptTokens = (state: any, questions: any) => Math.ceil(60 + tokensOf(state ?? '') +
+  Object.keys(questions || {}).reduce((n, k) => n + questionTokens(k, questions[k]), 0));
+
+/**
+ * The questions in parts within `maxQuestions` and `maxPromptTokens` (the estimate): one part when
+ * they fit; else the fewest parts of about even size (by the estimate), in question order. A
+ * question too large on its own goes alone.
+ */
+export function splitQuestions(state: any, questions: any, maxQuestions = Infinity, maxPromptTokens = Infinity): string[][] {
+  const all = Object.keys(questions || {});
+  if (all.length <= maxQuestions && (maxPromptTokens === Infinity || promptTokens(state, questions) <= maxPromptTokens)) return [all];
+  const room = maxPromptTokens - promptTokens(state, {});
+  const cost = all.map(n => questionTokens(n, questions[n]));
+  const total = cost.reduce((s, x) => s + x, 0);
+  const fits = (a: number, b: number) => b - a == 1 || (b - a <= maxQuestions && cost.slice(a, b).reduce((s, x) => s + x, 0) <= room);
+  for (let k = Math.max(2, Math.ceil(all.length / maxQuestions), Math.ceil(total / Math.max(1, room))); k < all.length; k++) {
+    // k parts: a cut where the running estimate passes each j/k of the total, or every ceil(n/k) questions
+    const cuts = [0];
+    for (let i = 0, acc = 0; i < all.length - 1; i++) {
+      acc += cost[i];
+      if (cuts.length < k && (acc >= total * cuts.length / k || i + 1 - cuts[cuts.length - 1] >= Math.ceil(all.length / k))) cuts.push(i + 1);
+    }
+    cuts.push(all.length);
+    if (cuts.every((c, j) => !j || fits(cuts[j - 1], c))) return cuts.slice(1).map((c, j) => all.slice(cuts[j], c));
+  }
+  return all.map(n => [n]);
+}
+
+const pick = (questions: any, names: string[]) => Object.fromEntries(names.map(n => [n, questions[n]]));
+const sum = (a: any, b: any): any => {
+  if (typeof a == 'number' && typeof b == 'number') return a + b;
+  if (a && b && typeof a == 'object' && typeof b == 'object' && !Array.isArray(a)) {
+    const out: any = {...a};
+    for (const k of Object.keys(b)) out[k] = k in a ? sum(a[k], b[k]) : b[k];
+    return out;
+  }
+  return a ?? b;
+};
+/** the replies of a split decision as one: `answers` merged by name, `usage` summed, the rest (`model`) of the first */
+export const combineDecisions = (bodies: any[]) => bodies.length == 1 ? bodies[0] : bodies.reduce((a, b) => ({
+  ...b, ...a,
+  answers: {...a?.answers, ...b?.answers},
+  ...((a?.usage || b?.usage) && {usage: sum(a?.usage, b?.usage)}),
+}));
+/**
+ * The reactive split: a request a server rejects as too large (HTTP 400 or 413 whose body mentions
+ * tokens, fields, context, a limit, or "too long / many / large") is sent again as two halves of its
+ * questions (the fetch driver: at most 3 times deep). Anything else: null (the error stands).
+ */
+const TOO_LARGE = /token|field|context|limit|exceed|too (long|many|large)/i;
+export const splitDecision = (req: any, error: any) => {
+  if (error?.status != 400 && error?.status != 413) return null;
+  if (!TOO_LARGE.test(text(error.body ?? ''))) return null;
+  const qs = req?.json?.questions;
+  const n = Array.isArray(qs) ? qs.length : Object.keys(qs || {}).length;
+  if (n < 2) return null;
+  const half = (a: number, b: number) => ({...req, json: {...req.json, questions: Array.isArray(qs) ? qs.slice(a, b) : pick(qs, Object.keys(qs).slice(a, b))}});
+  return [half(0, n >> 1), half(n >> 1, n)];
+};
+/**
+ * A decision request over the limits becomes a fetch-driver batch (sub-requests in parallel, one
+ * merged reply); every request can be halved when a server rejects it as too large. `split: false`:
+ * neither. `json` stays the whole request (what tests and `t.requests` see).
+ */
+const DEFAULT_MAX_QUESTIONS = 64;
+function splitting(build: (o: any) => any) {
+  return ({maxQuestions = DEFAULT_MAX_QUESTIONS, maxPromptTokens = Infinity, split = true, ...o}: any = {}) => {
+    const req = build(o);
+    if (split === false) return req;
+    const parts = splitQuestions(o.state, o.questions, Math.max(1, maxQuestions), maxPromptTokens);
+    const sub = (names: string[]) => {
+      const {url, method, json, parse} = build({...o, questions: pick(o.questions, names)});
+      return parse ? {url, method, json, parse} : {url, method, json};
+    };
+    return {...req, ...(parts.length > 1 && {batch: parts.map(sub)}), combine: combineDecisions, split: splitDecision};
+  };
+}
+
 const text = (x: any) => typeof x == 'string' ? x : JSON.stringify(x);
 // the dictionary form takes base64 files; OpenAI takes data URLs (the type from the magic bytes)
 const dataUrl = (b64: string) => b64.startsWith('data:') ? b64
@@ -101,4 +197,4 @@ function openai({url = '/api/decide', model, state, questions, images, ...rest}:
 }
 
 /** the dictionary-form request (TypeSafe, Ollama, OpenRouter, AI Gateway); `decide.openai()`: the same as an OpenAI Decisions request */
-export const decide = /*#__PURE__*/ Object.assign(dictionary, {openai})
+export const decide = /*#__PURE__*/ Object.assign(splitting(dictionary), {openai: splitting(openai)})

package/src/extra/ai/index.ts

@@ -20,7 +20,7 @@ export {outputJsonSchema} from './chat/output'
 // A-2 (2-W): WebMCP (experimental, D241)
 export {experimentalExposeWebMcp} from './webmcp'
 // L-3 (2-C): the chat behavior
-export {chat} from './chat/behavior'
+export {chat, openToolCalls} from './chat/behavior'
 // L-2 (2-T): transports, wave 1 (D248), each its own module (tree-shaken), and the Open Responses
 // event encoder (D273)
 export {openResponses} from './transports/openResponses'
@@ -40,3 +40,8 @@ export {fromAISDK} from './transports/fromAISDK'
 export {strictSchemas} from './schema/strict'
 // X-1 (3-X): MCP Apps, the view side
 export {makeMcpAppDriver} from './mcpApp'
+// PLAN-9 (A): catalogs (K-1), render (K-2), layout utilities (K-3), the compose behavior (C-1),
+// composeWith (T-1)
+export {defineCatalog, compose, composeWith, fromTree, toTree, removeNode, askCard} from './compose/index'
+// PLAN-9 M-1: the <Composed> marker
+export {Composed} from './compose/index'

package/src/extra/diagnostics/checks/dom.ts

@@ -25,8 +25,10 @@
  *      that matches in one Collection item is fine for all of them.
  *
  * SYG103 noise control (conditional rendering is normal): a selector whose
- * class/id/tag tokens all appear in the component's view source is assumed
- * to be conditionally rendered and is not reported. A selector that does not
+ * class/id/tag tokens all appear in the component's view source (or in the
+ * words sygnal/vite registered for it: markup drawn by view helpers in its
+ * module and its relative imports) is assumed to be conditionally rendered
+ * and is not reported. A selector that does not
  * appear in the view (typo, or an element rendered elsewhere) is reported as
  * info on the first sweep, and escalated per the rule above.
  *
@@ -71,12 +73,18 @@ onReset(() => {
 
 const unref = (t: any) => { if (t && typeof t.unref === 'function') t.unref(); return t }
 
+/**
+ * The view's source, plus the words sygnal/vite registered for the component (its module's and
+ * its relative imports' string literals: markup a view helper draws), when it did
+ */
 function viewSource(component: any): string {
   const view = component && component.view
   if (typeof view !== 'function') return ''
   let src = viewTokens.get(view)
   if (src === undefined) {
     try { src = Function.prototype.toString.call(view) } catch (_) { src = '' }
+    const registered = (globalThis as any).__SYGNAL_VIEW_TOKENS__?.get?.(view)
+    if (typeof registered == 'string') src += '\n' + registered
     viewTokens.set(view, src as string)
   }
   return src as string