@chatpanel/events 0.101.0 → 0.103.1

package/recipe-tool.js

@@ -1,161 +1,2 @@
-// The `recipe` tool — a workflow the model did once, kept as data, and run by name.
-//
-// The engine is @chatpanel/events recipe.js: a recipe is `call` / `parallel` / `batch` /
-// `pipeline` with `{ "$param": "x" }` slots, expanded, dry-run and run with no model in
-// the loop. What is here is the CONVERSATIONAL half the spine's amendment A2 asked for —
-// authored in chat, approved before it exists, declarative, never agent-written code:
-//
-//   save     the model proposes a recipe from what it just did ("you fetched two issues
-//            and compared them — keep that as `triage_pair`?"). The dry run is what the
-//            PERSON sees on the card: every step, every slot, every warning. Approval
-//            stores it; nothing runs.
-//   dry_run  the same report, on demand, for a saved recipe with real parameters.
-//   run      expand with the given parameters and execute through the turn's OWN toolset —
-//            so the destructive gate, redaction, the loop guard and the shield all apply
-//            to every step exactly as if the model had called it. A recipe composes calls;
-//            it is never a way around them.
-//
-// One registered tool, not three: a spec per verb is per-turn token cost on every armed
-// turn, and the description already lists the saved recipes by name and parameters, which
-// is the whole catalogue. Bound LATE to the toolset it lives in (`bind`), because the
-// toolset that runs its steps is the one it is a member of.
-//
-// Shared: the extension and the desktop arm the same tool over the same `recipes` prefs
-// section, so a recipe approved in one client runs in the other. The approval card and
-// the store are the host's (injected); everything the model sees is here.
-
-import { validateRecipe, expandRecipe, dryRunRecipe, runPlan, recipeParams, RECIPE_MODES } from './recipe.js';
-
-export const RECIPE_TOOL_NAME = 'recipe';
-
-const RECIPE_NAME_RE = /^[a-z][a-z0-9_-]{0,63}$/i;
-
-function catalogue(recipes) {
-  const list = (recipes || []).filter((r) => r && r.enabled !== false && r.name);
-  if (!list.length) return 'No recipes saved yet.';
-  return `Saved recipes: ${list.map((r) => {
-    const ps = recipeParams(r).map((p) => (p.required ? p.name : `${p.name}?`));
-    return `${r.name}(${ps.join(', ')})${r.description ? ` — ${r.description}` : ''}`;
-  }).join('; ')}.`;
-}
-
-/**
- * One spec. The shape a model needs to `save` is spelled out once, compactly; the
- * engine's validator names anything it got wrong.
- */
-export function recipeToolSpec(recipes) {
-  return {
-    name: RECIPE_TOOL_NAME,
-    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
-    description:
-      `Saved, repeatable tool workflows — run by name with no re-planning. ${catalogue(recipes)} `
-      + 'Actions: {"action":"run","name":"<recipe>","params":{…}} runs one; '
-      + '{"action":"dry_run","name":"<recipe>","params":{…}} shows what it would do without running; '
-      + '{"action":"save","recipe":{…}} proposes a NEW one after you have done a multi-step task the '
-      + 'user may repeat — the user approves it on a card. A recipe: {"name":"open_bug","description":"…",'
-      + '"mode":"call","tool":"<tool name, e.g. mcp_github__create_issue>","arguments":{"title":{"$param":"title"},"labels":["bug"]}}. '
-      + `Modes: ${RECIPE_MODES.join(' | ')} — parallel takes "calls":[{tool,arguments}], batch takes "tool"+"items":[{arguments}], `
-      + 'pipeline takes "steps":[{tool,arguments,inputMapping:{arg:"$json.path"|"$text"}}]. '
-      + 'Use {"$param":"x"} for anything the user will supply each time; a "default" makes it optional.',
-    parameters: {
-      type: 'object',
-      properties: {
-        action: { type: 'string', enum: ['run', 'dry_run', 'save'] },
-        name: { type: 'string', description: 'Recipe name, for run / dry_run.' },
-        params: { type: 'object', description: 'Parameter values, for run / dry_run.', additionalProperties: true },
-        recipe: { type: 'object', description: 'The recipe to save, for save.', additionalProperties: true },
-      },
-      required: ['action'],
-    },
-  };
-}
-
-/** The card a person approves: what it does, step by step, and what the dry run flagged. */
-export function describeRecipeForApproval(recipe, report) {
-  const lines = [`${recipe.name}${recipe.description ? ` — ${recipe.description}` : ''}`, `Mode: ${recipe.mode}`];
-  const ps = recipeParams(recipe);
-  if (ps.length) lines.push(`Parameters: ${ps.map((p) => (p.required ? p.name : `${p.name} (optional)`)).join(', ')}`);
-  const calls = report?.calls || [];
-  calls.forEach((c, i) => {
-    const args = JSON.stringify(c.arguments);
-    lines.push(`${calls.length > 1 ? `${i + 1}. ` : ''}${c.tool}${args && args !== '{}' ? ` ${args.length > 140 ? `${args.slice(0, 137)}…` : args}` : ''}${c.mappedLater?.length ? ` (+ ${c.mappedLater.join(', ')} from the previous step)` : ''}`);
-  });
-  for (const w of report?.warnings || []) lines.push(`⚠ ${w.message}`);
-  lines.push('Saved recipes run with no further planning; destructive steps still ask each time.');
-  return lines.join('\n');
-}
-
-const json = (v) => JSON.stringify(v);
-
-/**
- * @param recipes     the saved list (settings.recipes)
- * @param confirmSave async (detail, recipe) => 'allow' | 'deny' — the surface's card. Absent on a
- *                    surface with no window: `save` is then refused, `run` still works.
- * @param saveRecipe  async (recipe) => void — persist an approved one
- */
-export function recipeToolProvider({ recipes = [], confirmSave = null, saveRecipe = null } = {}) {
-  let bound = null; // { execute, specs, traits, hiddenVia }
-  const byName = new Map((recipes || []).filter((r) => r?.name && r.enabled !== false).map((r) => [r.name, r]));
-
-  // Steps name REAL tools; a tool that lives behind a dispatcher (`mcp_gh__get_issue`
-  // behind `mcp`) is reached through it, so every guard that keys on the action fires.
-  const execute = (tool, args, meta) => {
-    if (!bound) return json({ error: 'The recipe tool is not bound to a toolset yet.' });
-    const via = bound.hiddenVia?.get(tool);
-    return via ? bound.execute(via, { action: tool, args }, meta) : bound.execute(tool, args, meta);
-  };
-  const specsForDryRun = () => (bound ? [...(bound.specs || []), ...(bound.reach || [])].filter((s) => s?.name !== RECIPE_TOOL_NAME) : null);
-  const traitsOf = (tool) => bound?.traits?.get(tool) || null;
-
-  return {
-    id: 'recipe',
-    specs: [recipeToolSpec(recipes)],
-    system: byName.size ? 'Saved recipes exist (see the `recipe` tool). When the user asks for one by name or describes what one does, run it rather than re-planning the steps.' : '',
-    bind(toolset) {
-      bound = { execute: toolset.execute.bind(toolset), specs: toolset.specs, reach: toolset.reach, traits: toolset.traits, hiddenVia: toolset.hiddenVia };
-    },
-    async execute(name, input) {
-      if (name !== RECIPE_TOOL_NAME) return json({ error: `Unknown tool: ${name}` });
-      const action = String(input?.action || '');
-
-      if (action === 'save') {
-        const recipe = input?.recipe;
-        const v = validateRecipe(recipe);
-        if (!v.ok) return json({ error: 'The recipe is not valid.', problems: v.errors });
-        if (!RECIPE_NAME_RE.test(recipe.name)) return json({ error: 'name must be a short identifier: letters, digits, _ or -.' });
-        if (byName.has(recipe.name)) return json({ error: `A recipe named "${recipe.name}" already exists. Pick another name.` });
-        if (!confirmSave || !saveRecipe) return json({ error: 'Saving a recipe needs the user\'s approval, which this surface cannot ask for. Describe the recipe to the user and suggest saving it from the side panel.' });
-        const report = dryRunRecipe(recipe, {}, { specs: specsForDryRun(), traitsOf: bound ? (t) => traitsOf(t) || undefined : null });
-        // Missing parameters are the POINT of a template; only structural problems block.
-        const blocking = (report.warnings || []).filter((w) => w.code === 'unknown_tool');
-        if (blocking.length) return json({ error: 'The recipe names tools that are not available in this conversation.', problems: blocking.map((w) => w.message) });
-        const detail = describeRecipeForApproval(recipe, report);
-        const decision = await confirmSave(detail, recipe);
-        if (decision !== 'allow') return json({ error: `The user did not save "${recipe.name}". Do not propose it again this turn.`, declined: true });
-        const stored = { ...recipe, enabled: true, createdAt: Date.now() };
-        await saveRecipe(stored);
-        byName.set(stored.name, stored);
-        return json({ saved: stored.name, params: recipeParams(stored).map((p) => p.name), hint: `Run it later with {"action":"run","name":"${stored.name}","params":{…}} or by typing /${stored.name}.` });
-      }
-
-      const recipe = byName.get(String(input?.name || ''));
-      if (!recipe) return json({ error: `No recipe named "${input?.name}".`, available: [...byName.keys()] });
-      const params = input?.params && typeof input.params === 'object' ? input.params : {};
-
-      if (action === 'dry_run') {
-        const report = dryRunRecipe(recipe, params, { specs: specsForDryRun(), traitsOf: bound ? (t) => traitsOf(t) || undefined : null });
-        return json({ name: recipe.name, ok: report.ok, missing: report.missing, calls: report.calls.map((c) => ({ tool: c.tool, arguments: c.arguments, known: c.known, destructive: c.traits?.destructive === true, mappedLater: c.mappedLater })), warnings: report.warnings });
-      }
-
-      if (action === 'run') {
-        const ex = expandRecipe(recipe, params);
-        if (!ex.plan) return json({ error: 'The saved recipe is not valid.', problems: ex.errors });
-        if (!ex.ok) return json({ error: `Missing parameter(s): ${ex.missing.join(', ')}.`, params: recipeParams(recipe) });
-        const result = await runPlan(ex.plan, { execute, traitsOf: (t) => traitsOf(t) || undefined });
-        return json({ name: recipe.name, ...result });
-      }
-
-      return json({ error: `Unknown action "${action}". Use run, dry_run or save.` });
-    },
-  };
-}
+import{validateRecipe as x,expandRecipe as j,dryRunRecipe as k,runPlan as E,recipeParams as v,RECIPE_MODES as P}from"./recipe.js";const y="recipe",R=/^[a-z][a-z0-9_-]{0,63}$/i;function O(s){const m=(s||[]).filter(n=>n&&n.enabled!==!1&&n.name);return m.length?`Saved recipes: ${m.map(n=>{const t=v(n).map(i=>i.required?i.name:`${i.name}?`);return`${n.name}(${t.join(", ")})${n.description?` — ${n.description}`:""}`}).join("; ")}.`:"No recipes saved yet."}function S(s){return{name:y,annotations:{readOnlyHint:!1,destructiveHint:!1,idempotentHint:!1},description:`Saved, repeatable tool workflows — run by name with no re-planning. ${O(s)} Actions: {"action":"run","name":"<recipe>","params":{…}} runs one; {"action":"dry_run","name":"<recipe>","params":{…}} shows what it would do without running; {"action":"save","recipe":{…}} proposes a NEW one after you have done a multi-step task the user may repeat — the user approves it on a card. A recipe: {"name":"open_bug","description":"…","mode":"call","tool":"<tool name, e.g. mcp_github__create_issue>","arguments":{"title":{"$param":"title"},"labels":["bug"]}}. Modes: ${P.join(" | ")} — parallel takes "calls":[{tool,arguments}], batch takes "tool"+"items":[{arguments}], pipeline takes "steps":[{tool,arguments,inputMapping:{arg:"$json.path"|"$text"}}]. Use {"$param":"x"} for anything the user will supply each time; a "default" makes it optional.`,parameters:{type:"object",properties:{action:{type:"string",enum:["run","dry_run","save"]},name:{type:"string",description:"Recipe name, for run / dry_run."},params:{type:"object",description:"Parameter values, for run / dry_run.",additionalProperties:!0},recipe:{type:"object",description:"The recipe to save, for save.",additionalProperties:!0}},required:["action"]}}}function T(s,m){const n=[`${s.name}${s.description?` — ${s.description}`:""}`,`Mode: ${s.mode}`],t=v(s);t.length&&n.push(`Parameters: ${t.map(o=>o.required?o.name:`${o.name} (optional)`).join(", ")}`);const i=m?.calls||[];i.forEach((o,g)=>{const u=JSON.stringify(o.arguments);n.push(`${i.length>1?`${g+1}. `:""}${o.tool}${u&&u!=="{}"?` ${u.length>140?`${u.slice(0,137)}…`:u}`:""}${o.mappedLater?.length?` (+ ${o.mappedLater.join(", ")} from the previous step)`:""}`)});for(const o of m?.warnings||[])n.push(`⚠ ${o.message}`);return n.push("Saved recipes run with no further planning; destructive steps still ask each time."),n.join(`
+`)}const a=s=>JSON.stringify(s);function A({recipes:s=[],confirmSave:m=null,saveRecipe:n=null}={}){let t=null;const i=new Map((s||[]).filter(e=>e?.name&&e.enabled!==!1).map(e=>[e.name,e])),o=(e,c,d)=>{if(!t)return a({error:"The recipe tool is not bound to a toolset yet."});const l=t.hiddenVia?.get(e);return l?t.execute(l,{action:e,args:c},d):t.execute(e,c,d)},g=()=>t?[...t.specs||[],...t.reach||[]].filter(e=>e?.name!==y):null,u=e=>t?.traits?.get(e)||null;return{id:"recipe",specs:[S(s)],system:i.size?"Saved recipes exist (see the `recipe` tool). When the user asks for one by name or describes what one does, run it rather than re-planning the steps.":"",bind(e){t={execute:e.execute.bind(e),specs:e.specs,reach:e.reach,traits:e.traits,hiddenVia:e.hiddenVia}},async execute(e,c){if(e!==y)return a({error:`Unknown tool: ${e}`});const d=String(c?.action||"");if(d==="save"){const r=c?.recipe,p=x(r);if(!p.ok)return a({error:"The recipe is not valid.",problems:p.errors});if(!R.test(r.name))return a({error:"name must be a short identifier: letters, digits, _ or -."});if(i.has(r.name))return a({error:`A recipe named "${r.name}" already exists. Pick another name.`});if(!m||!n)return a({error:"Saving a recipe needs the user's approval, which this surface cannot ask for. Describe the recipe to the user and suggest saving it from the side panel."});const $=k(r,{},{specs:g(),traitsOf:t?f=>u(f)||void 0:null}),w=($.warnings||[]).filter(f=>f.code==="unknown_tool");if(w.length)return a({error:"The recipe names tools that are not available in this conversation.",problems:w.map(f=>f.message)});const _=T(r,$);if(await m(_,r)!=="allow")return a({error:`The user did not save "${r.name}". Do not propose it again this turn.`,declined:!0});const h={...r,enabled:!0,createdAt:Date.now()};return await n(h),i.set(h.name,h),a({saved:h.name,params:v(h).map(f=>f.name),hint:`Run it later with {"action":"run","name":"${h.name}","params":{…}} or by typing /${h.name}.`})}const l=i.get(String(c?.name||""));if(!l)return a({error:`No recipe named "${c?.name}".`,available:[...i.keys()]});const b=c?.params&&typeof c.params=="object"?c.params:{};if(d==="dry_run"){const r=k(l,b,{specs:g(),traitsOf:t?p=>u(p)||void 0:null});return a({name:l.name,ok:r.ok,missing:r.missing,calls:r.calls.map(p=>({tool:p.tool,arguments:p.arguments,known:p.known,destructive:p.traits?.destructive===!0,mappedLater:p.mappedLater})),warnings:r.warnings})}if(d==="run"){const r=j(l,b);if(!r.plan)return a({error:"The saved recipe is not valid.",problems:r.errors});if(!r.ok)return a({error:`Missing parameter(s): ${r.missing.join(", ")}.`,params:v(l)});const p=await E(r.plan,{execute:o,traitsOf:$=>u($)||void 0});return a({name:l.name,...p})}return a({error:`Unknown action "${d}". Use run, dry_run or save.`})}}}export{y as RECIPE_TOOL_NAME,T as describeRecipeForApproval,A as recipeToolProvider,S as recipeToolSpec};

package/recipe.js

@@ -1,264 +1 @@
-// Recipes — a multi-step tool workflow written down once and run by name, with no model
-// in the loop.
-//
-// Skills are prompts: they tell a model what to do and the model decides which tools to
-// call. A recipe is the other thing — the DECISION already made, as data: "open_bug" is
-// `create_issue` with `labels: ["bug"]` baked in and `title`/`body` filled from the
-// caller; "triage_pair" fetches two issues at once; "search_then_read" searches, then
-// reads the first hit. It runs identically every time, from any client, with no tokens
-// spent deciding, and it is the shape the harness spine calls class R: declarative,
-// permissioned, never agent-written code. Amendment A2 asked for automations to be
-// authored conversationally and approved before they run; this is what gets approved.
-//
-// Four modes, matching the primitives a round already has: `call` (one tool),
-// `parallel` (independent calls, run through tool-round.js so reads overlap), `batch` (one
-// tool, many argument sets) and `pipeline` (each step may map values out of the previous
-// step's result with `inputMapping`: "$text" for its text, "$json" for it parsed,
-// "$json.items.0.key" for a path inside).
-//
-// Two properties are load-bearing:
-//   • DRY RUN before side effects — `dryRunRecipe` resolves every parameter and names
-//     every unknown tool, missing required field and destructive call without executing
-//     anything. It is the propose step of propose → approve → activate.
-//   • PARTIAL FAILURE IS RECOVERABLE — a parallel/batch run returns every sibling's result
-//     plus `failedIndexes`; a pipeline stops at the failing step and returns the outputs
-//     of the steps before it, plus which mappings resolved and which did not. Nothing is
-//     retried blindly, and nothing that succeeded is lost.
-//
-// Pure. Execution, tool specs and traits are injected; nothing here knows a model, a
-// window, or where recipes are stored.
-
-import { runToolRound } from './tool-round.js';
-import { toolTraits, needsConfirmation } from './tool-traits.js';
-
-export const RECIPE_MODES = Object.freeze(['call', 'parallel', 'batch', 'pipeline']);
-
-export class RecipeError extends Error {
-  constructor(code, message) { super(message); this.name = 'RecipeError'; this.code = code; }
-}
-
-const isRecord = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
-const isParamRef = (v) => isRecord(v) && typeof v.$param === 'string' && Object.keys(v).every((k) => k === '$param' || k === 'default');
-
-/** Every `{ "$param": name }` a recipe reads, in first-seen order. */
-export function recipeParams(recipe) {
-  const names = [];
-  const seen = new Set();
-  const walk = (v) => {
-    if (isParamRef(v)) { if (!seen.has(v.$param)) { seen.add(v.$param); names.push({ name: v.$param, required: !('default' in v), default: v.default }); } return; }
-    if (Array.isArray(v)) v.forEach(walk);
-    else if (isRecord(v)) Object.values(v).forEach(walk);
-  };
-  walk(recipe);
-  return names;
-}
-
-/** Structural validity — the errors a person authoring one needs to see. */
-export function validateRecipe(recipe) {
-  const errors = [];
-  if (!isRecord(recipe)) return { ok: false, errors: ['recipe must be an object'] };
-  if (!recipe.name || typeof recipe.name !== 'string' || !/^[a-z][a-z0-9_-]{0,63}$/i.test(recipe.name)) errors.push('name: a short identifier (letters, digits, _ -) is required');
-  if (!RECIPE_MODES.includes(recipe.mode)) errors.push(`mode: one of ${RECIPE_MODES.join(', ')}`);
-  const call = (c, where) => {
-    if (!isRecord(c)) { errors.push(`${where}: must be an object`); return; }
-    if (!c.tool || typeof c.tool !== 'string') errors.push(`${where}.tool: required`);
-    if (c.arguments !== undefined && !isRecord(c.arguments)) errors.push(`${where}.arguments: must be an object`);
-    if (c.inputMapping !== undefined && (!isRecord(c.inputMapping) || Object.values(c.inputMapping).some((m) => typeof m !== 'string' || !/^\$(text|json)(\.[^.\s]+)*$/.test(m)))) {
-      errors.push(`${where}.inputMapping: values must be "$text", "$json" or "$json.<path>"`);
-    }
-    if (c.onMappingMissing !== undefined && !['continue', 'fail'].includes(c.onMappingMissing)) errors.push(`${where}.onMappingMissing: "continue" or "fail"`);
-  };
-  switch (recipe.mode) {
-    case 'call': call(recipe, 'recipe'); break;
-    case 'parallel':
-      if (!Array.isArray(recipe.calls) || !recipe.calls.length) errors.push('calls: a non-empty array');
-      else recipe.calls.forEach((c, i) => call(c, `calls[${i}]`));
-      break;
-    case 'batch':
-      if (!recipe.tool || typeof recipe.tool !== 'string') errors.push('tool: required');
-      if (!Array.isArray(recipe.items) || !recipe.items.length) errors.push('items: a non-empty array');
-      else recipe.items.forEach((it, i) => { if (!isRecord(it) || !isRecord(it.arguments)) errors.push(`items[${i}].arguments: must be an object`); });
-      break;
-    case 'pipeline':
-      if (!Array.isArray(recipe.steps) || !recipe.steps.length) errors.push('steps: a non-empty array');
-      else {
-        recipe.steps.forEach((s, i) => call(s, `steps[${i}]`));
-        if (isRecord(recipe.steps[0]) && recipe.steps[0].inputMapping) errors.push('steps[0].inputMapping: the first step has no previous result');
-      }
-      break;
-    default: break;
-  }
-  return { ok: errors.length === 0, errors };
-}
-
-/**
- * Substitute parameters. Returns the plan — a list of concrete calls in the recipe's mode
- * — and the names of any parameters missing without a default. A missing parameter is
- * reported, not thrown: the caller decides whether to ask for it or fail.
- */
-export function expandRecipe(recipe, params = {}) {
-  const v = validateRecipe(recipe);
-  if (!v.ok) return { ok: false, errors: v.errors, missing: [], plan: null };
-  const missing = new Set();
-  const fill = (x) => {
-    if (isParamRef(x)) {
-      if (Object.prototype.hasOwnProperty.call(params, x.$param) && params[x.$param] !== undefined) return params[x.$param];
-      if ('default' in x) return x.default;
-      missing.add(x.$param);
-      return undefined;
-    }
-    if (Array.isArray(x)) return x.map(fill);
-    if (isRecord(x)) {
-      const out = {};
-      for (const [k, val] of Object.entries(x)) { const f = fill(val); if (f !== undefined) out[k] = f; }
-      return out;
-    }
-    return x;
-  };
-  const one = (c) => ({ tool: c.tool, arguments: fill(c.arguments || {}), ...(c.inputMapping ? { inputMapping: { ...c.inputMapping } } : {}), ...(c.onMappingMissing ? { onMappingMissing: c.onMappingMissing } : {}) });
-  let calls;
-  switch (recipe.mode) {
-    case 'call': calls = [one(recipe)]; break;
-    case 'parallel': calls = recipe.calls.map(one); break;
-    case 'batch': calls = recipe.items.map((it) => ({ tool: recipe.tool, arguments: fill(it.arguments) })); break;
-    case 'pipeline': calls = recipe.steps.map(one); break;
-    default: calls = [];
-  }
-  return { ok: missing.size === 0, errors: [], missing: [...missing], plan: { name: recipe.name, mode: recipe.mode, calls } };
-}
-
-// ── mapping ──────────────────────────────────────────────────────────────────────────
-
-const textOf = (r) => (typeof r === 'string' ? r : r && typeof r === 'object' && typeof r.text === 'string' ? r.text : r == null ? '' : JSON.stringify(r));
-
-function parseJson(text) {
-  try { return { ok: true, value: JSON.parse(text) }; } catch { return { ok: false }; }
-}
-
-/**
- * Resolve one step's `inputMapping` against the previous result.
- * @returns `{ arguments, mapped: { [arg]: value }, skipped: [{ arg, expr, reason }] }`
- */
-export function mapInput(previous, mapping = {}, base = {}) {
-  const args = { ...base };
-  const mapped = {};
-  const skipped = [];
-  const text = textOf(previous);
-  let json;
-  for (const [arg, expr] of Object.entries(mapping || {})) {
-    if (expr === '$text') { args[arg] = text; mapped[arg] = text; continue; }
-    if (!expr.startsWith('$json')) { skipped.push({ arg, expr, reason: 'unknown expression' }); continue; }
-    if (json === undefined) json = parseJson(text);
-    if (!json.ok) { skipped.push({ arg, expr, reason: 'previous result is not JSON' }); continue; }
-    let cur = json.value;
-    const path = expr.slice(5).split('.').filter(Boolean);
-    let found = true;
-    for (const seg of path) {
-      if (Array.isArray(cur) && /^\d+$/.test(seg)) cur = cur[Number(seg)];
-      else if (isRecord(cur) && Object.prototype.hasOwnProperty.call(cur, seg)) cur = cur[seg];
-      else { found = false; break; }
-    }
-    if (!found || cur === undefined) { skipped.push({ arg, expr, reason: 'path not found in previous result' }); continue; }
-    args[arg] = cur;
-    mapped[arg] = cur;
-  }
-  return { arguments: args, mapped, skipped };
-}
-
-// ── dry run ──────────────────────────────────────────────────────────────────────────
-
-/**
- * Everything a person should know before approving: unknown tools, missing required
- * fields, destructive calls, and which arguments a pipeline will only learn at run time.
- *
- * @param specs    the tool specs the runtime will execute against (for existence and
- *                 required fields); omit to skip those checks
- * @param traitsOf `(tool) => traits`; defaults to toolTraits on the spec or name
- */
-export function dryRunRecipe(recipe, params = {}, { specs = null, traitsOf = null } = {}) {
-  const ex = expandRecipe(recipe, params);
-  if (!ex.plan) return { ok: false, errors: ex.errors, missing: ex.missing, calls: [], warnings: [], destructive: [] };
-  const byName = specs ? new Map(specs.filter((s) => s?.name).map((s) => [s.name, s])) : null;
-  const traits = traitsOf || ((tool) => toolTraits(byName?.get(tool) || tool));
-  const warnings = [];
-  const destructive = [];
-  const calls = ex.plan.calls.map((c, i) => {
-    const spec = byName?.get(c.tool);
-    const known = byName ? !!spec : null;
-    const t = traits(c.tool);
-    const mappedLater = new Set(Object.keys(c.inputMapping || {}));
-    const required = Array.isArray(spec?.parameters?.required) ? spec.parameters.required : Array.isArray(spec?.inputSchema?.required) ? spec.inputSchema.required : [];
-    const missingRequired = required.filter((k) => c.arguments[k] === undefined && !mappedLater.has(k));
-    const row = { index: i, tool: c.tool, arguments: c.arguments, known, traits: t, missingRequired, mappedLater: [...mappedLater] };
-    if (known === false) warnings.push({ index: i, code: 'unknown_tool', message: `No tool named "${c.tool}" is available.` });
-    if (missingRequired.length) warnings.push({ index: i, code: 'missing_required', message: `"${c.tool}" needs ${missingRequired.join(', ')}.` });
-    if (needsConfirmation(t)) { destructive.push(i); warnings.push({ index: i, code: 'destructive', message: `"${c.tool}" is destructive.` }); }
-    if (ex.plan.mode === 'pipeline' && i > 0 && !mappedLater.size) warnings.push({ index: i, code: 'no_mapping', message: `steps[${i}] uses nothing from the previous step; was that intended?` });
-    return row;
-  });
-  const blocking = ex.missing.length > 0 || warnings.some((w) => w.code === 'unknown_tool' || w.code === 'missing_required');
-  return { ok: !blocking, errors: [], missing: ex.missing, plan: ex.plan, calls, warnings, destructive };
-}
-
-// ── run ──────────────────────────────────────────────────────────────────────────────
-
-const defaultIsError = (r) => {
-  if (r == null) return false;
-  if (typeof r === 'string') return /^error:/i.test(r) || /^\{\s*"error"/.test(r);
-  return typeof r === 'object' && (r.error != null || r.isError === true);
-};
-
-/**
- * Run an expanded plan. `execute(tool, arguments, meta)` is the host's toolset executor —
- * every guard, redaction and confirmation it wraps applies unchanged, because a recipe is
- * a way of composing calls, never a way around them.
- */
-export async function runPlan(plan, { execute, traitsOf, concurrent, isError = defaultIsError, onStart, onDone } = {}) {
-  if (typeof execute !== 'function') throw new RecipeError('BAD_RUN', 'execute required');
-  if (!plan || !Array.isArray(plan.calls)) throw new RecipeError('BAD_PLAN', 'plan.calls required');
-  const meta = { recipe: plan.name, mode: plan.mode };
-
-  if (plan.mode === 'pipeline') {
-    const steps = [];
-    let previous;
-    for (let i = 0; i < plan.calls.length; i += 1) {
-      const c = plan.calls[i];
-      let args = c.arguments;
-      let mapped = {};
-      let skipped = [];
-      if (i > 0 && c.inputMapping) {
-        const m = mapInput(previous, c.inputMapping, c.arguments);
-        args = m.arguments; mapped = m.mapped; skipped = m.skipped;
-        if (skipped.length && c.onMappingMissing === 'fail') {
-          steps.push({ index: i, tool: c.tool, arguments: args, mappedArguments: mapped, skippedMappings: skipped, result: null, status: 'skipped' });
-          return { status: 'failed', failedStep: i, reason: 'mapping_missing', steps, finalResult: null };
-        }
-      }
-      onStart?.({ name: c.tool, input: args }, i);
-      let result;
-      try { result = await execute(c.tool, args, { ...meta, step: i }); } catch (e) { result = { error: `Tool ${c.tool} failed: ${e?.message || e}` }; }
-      onDone?.({ name: c.tool, input: args }, i, result);
-      const failed = isError(result);
-      steps.push({ index: i, tool: c.tool, arguments: args, mappedArguments: mapped, skippedMappings: skipped, result, status: failed ? 'failed' : 'ok' });
-      if (failed) return { status: 'failed', failedStep: i, reason: 'tool_error', steps, finalResult: null };
-      previous = result;
-    }
-    return { status: 'completed', steps, finalResult: previous };
-  }
-
-  const calls = plan.calls.map((c) => ({ name: c.tool, input: c.arguments }));
-  const round = await runToolRound(calls, {
-    execute: (call, i) => execute(call.name, call.input, { ...meta, index: i }),
-    traitsOf: traitsOf ? (c) => traitsOf(c.name) : undefined,
-    concurrent, isError, onStart, onDone,
-  });
-  return { status: round.status, succeeded: round.succeeded, failed: round.failed, failedIndexes: round.failedIndexes, results: round.results, coalesced: round.coalesced };
-}
-
-/** Expand, then run. Missing parameters fail before anything executes. */
-export async function runRecipe(recipe, params, options) {
-  const ex = expandRecipe(recipe, params);
-  if (!ex.plan) throw new RecipeError('INVALID', ex.errors.join('; '));
-  if (!ex.ok) throw new RecipeError('MISSING_PARAMS', `missing: ${ex.missing.join(', ')}`);
-  return runPlan(ex.plan, options);
-}
+import{runToolRound as R}from"./tool-round.js";import{toolTraits as O,needsConfirmation as q}from"./tool-traits.js";const j=Object.freeze(["call","parallel","batch","pipeline"]);class M extends Error{constructor(n,l){super(l),this.name="RecipeError",this.code=n}}const c=e=>e!==null&&typeof e=="object"&&!Array.isArray(e),w=e=>c(e)&&typeof e.$param=="string"&&Object.keys(e).every(n=>n==="$param"||n==="default");function J(e){const n=[],l=new Set,s=t=>{if(w(t)){l.has(t.$param)||(l.add(t.$param),n.push({name:t.$param,required:!("default"in t),default:t.default}));return}Array.isArray(t)?t.forEach(s):c(t)&&Object.values(t).forEach(s)};return s(e),n}function S(e){const n=[];if(!c(e))return{ok:!1,errors:["recipe must be an object"]};(!e.name||typeof e.name!="string"||!/^[a-z][a-z0-9_-]{0,63}$/i.test(e.name))&&n.push("name: a short identifier (letters, digits, _ -) is required"),j.includes(e.mode)||n.push(`mode: one of ${j.join(", ")}`);const l=(s,t)=>{if(!c(s)){n.push(`${t}: must be an object`);return}(!s.tool||typeof s.tool!="string")&&n.push(`${t}.tool: required`),s.arguments!==void 0&&!c(s.arguments)&&n.push(`${t}.arguments: must be an object`),s.inputMapping!==void 0&&(!c(s.inputMapping)||Object.values(s.inputMapping).some(p=>typeof p!="string"||!/^\$(text|json)(\.[^.\s]+)*$/.test(p)))&&n.push(`${t}.inputMapping: values must be "$text", "$json" or "$json.<path>"`),s.onMappingMissing!==void 0&&!["continue","fail"].includes(s.onMappingMissing)&&n.push(`${t}.onMappingMissing: "continue" or "fail"`)};switch(e.mode){case"call":l(e,"recipe");break;case"parallel":!Array.isArray(e.calls)||!e.calls.length?n.push("calls: a non-empty array"):e.calls.forEach((s,t)=>l(s,`calls[${t}]`));break;case"batch":(!e.tool||typeof e.tool!="string")&&n.push("tool: required"),!Array.isArray(e.items)||!e.items.length?n.push("items: a non-empty array"):e.items.forEach((s,t)=>{(!c(s)||!c(s.arguments))&&n.push(`items[${t}].arguments: must be an object`)});break;case"pipeline":!Array.isArray(e.steps)||!e.steps.length?n.push("steps: a non-empty array"):(e.steps.forEach((s,t)=>l(s,`steps[${t}]`)),c(e.steps[0])&&e.steps[0].inputMapping&&n.push("steps[0].inputMapping: the first step has no previous result"));break;default:break}return{ok:n.length===0,errors:n}}function x(e,n={}){const l=S(e);if(!l.ok)return{ok:!1,errors:l.errors,missing:[],plan:null};const s=new Set,t=r=>{if(w(r)){if(Object.prototype.hasOwnProperty.call(n,r.$param)&&n[r.$param]!==void 0)return n[r.$param];if("default"in r)return r.default;s.add(r.$param);return}if(Array.isArray(r))return r.map(t);if(c(r)){const m={};for(const[f,o]of Object.entries(r)){const a=t(o);a!==void 0&&(m[f]=a)}return m}return r},p=r=>({tool:r.tool,arguments:t(r.arguments||{}),...r.inputMapping?{inputMapping:{...r.inputMapping}}:{},...r.onMappingMissing?{onMappingMissing:r.onMappingMissing}:{}});let d;switch(e.mode){case"call":d=[p(e)];break;case"parallel":d=e.calls.map(p);break;case"batch":d=e.items.map(r=>({tool:e.tool,arguments:t(r.arguments)}));break;case"pipeline":d=e.steps.map(p);break;default:d=[]}return{ok:s.size===0,errors:[],missing:[...s],plan:{name:e.name,mode:e.mode,calls:d}}}const _=e=>typeof e=="string"?e:e&&typeof e=="object"&&typeof e.text=="string"?e.text:e==null?"":JSON.stringify(e);function E(e){try{return{ok:!0,value:JSON.parse(e)}}catch{return{ok:!1}}}function N(e,n={},l={}){const s={...l},t={},p=[],d=_(e);let r;for(const[m,f]of Object.entries(n||{})){if(f==="$text"){s[m]=d,t[m]=d;continue}if(!f.startsWith("$json")){p.push({arg:m,expr:f,reason:"unknown expression"});continue}if(r===void 0&&(r=E(d)),!r.ok){p.push({arg:m,expr:f,reason:"previous result is not JSON"});continue}let o=r.value;const a=f.slice(5).split(".").filter(Boolean);let i=!0;for(const u of a)if(Array.isArray(o)&&/^\d+$/.test(u))o=o[Number(u)];else if(c(o)&&Object.prototype.hasOwnProperty.call(o,u))o=o[u];else{i=!1;break}if(!i||o===void 0){p.push({arg:m,expr:f,reason:"path not found in previous result"});continue}s[m]=o,t[m]=o}return{arguments:s,mapped:t,skipped:p}}function L(e,n={},{specs:l=null,traitsOf:s=null}={}){const t=x(e,n);if(!t.plan)return{ok:!1,errors:t.errors,missing:t.missing,calls:[],warnings:[],destructive:[]};const p=l?new Map(l.filter(a=>a?.name).map(a=>[a.name,a])):null,d=s||(a=>O(p?.get(a)||a)),r=[],m=[],f=t.plan.calls.map((a,i)=>{const u=p?.get(a.tool),g=p?!!u:null,k=d(a.tool),h=new Set(Object.keys(a.inputMapping||{})),$=(Array.isArray(u?.parameters?.required)?u.parameters.required:Array.isArray(u?.inputSchema?.required)?u.inputSchema.required:[]).filter(A=>a.arguments[A]===void 0&&!h.has(A)),y={index:i,tool:a.tool,arguments:a.arguments,known:g,traits:k,missingRequired:$,mappedLater:[...h]};return g===!1&&r.push({index:i,code:"unknown_tool",message:`No tool named "${a.tool}" is available.`}),$.length&&r.push({index:i,code:"missing_required",message:`"${a.tool}" needs ${$.join(", ")}.`}),q(k)&&(m.push(i),r.push({index:i,code:"destructive",message:`"${a.tool}" is destructive.`})),t.plan.mode==="pipeline"&&i>0&&!h.size&&r.push({index:i,code:"no_mapping",message:`steps[${i}] uses nothing from the previous step; was that intended?`}),y});return{ok:!(t.missing.length>0||r.some(a=>a.code==="unknown_tool"||a.code==="missing_required")),errors:[],missing:t.missing,plan:t.plan,calls:f,warnings:r,destructive:m}}const I=e=>e==null?!1:typeof e=="string"?/^error:/i.test(e)||/^\{\s*"error"/.test(e):typeof e=="object"&&(e.error!=null||e.isError===!0);async function P(e,{execute:n,traitsOf:l,concurrent:s,isError:t=I,onStart:p,onDone:d}={}){if(typeof n!="function")throw new M("BAD_RUN","execute required");if(!e||!Array.isArray(e.calls))throw new M("BAD_PLAN","plan.calls required");const r={recipe:e.name,mode:e.mode};if(e.mode==="pipeline"){const o=[];let a;for(let i=0;i<e.calls.length;i+=1){const u=e.calls[i];let g=u.arguments,k={},h=[];if(i>0&&u.inputMapping){const y=N(a,u.inputMapping,u.arguments);if(g=y.arguments,k=y.mapped,h=y.skipped,h.length&&u.onMappingMissing==="fail")return o.push({index:i,tool:u.tool,arguments:g,mappedArguments:k,skippedMappings:h,result:null,status:"skipped"}),{status:"failed",failedStep:i,reason:"mapping_missing",steps:o,finalResult:null}}p?.({name:u.tool,input:g},i);let b;try{b=await n(u.tool,g,{...r,step:i})}catch(y){b={error:`Tool ${u.tool} failed: ${y?.message||y}`}}d?.({name:u.tool,input:g},i,b);const $=t(b);if(o.push({index:i,tool:u.tool,arguments:g,mappedArguments:k,skippedMappings:h,result:b,status:$?"failed":"ok"}),$)return{status:"failed",failedStep:i,reason:"tool_error",steps:o,finalResult:null};a=b}return{status:"completed",steps:o,finalResult:a}}const m=e.calls.map(o=>({name:o.tool,input:o.arguments})),f=await R(m,{execute:(o,a)=>n(o.name,o.input,{...r,index:a}),traitsOf:l?o=>l(o.name):void 0,concurrent:s,isError:t,onStart:p,onDone:d});return{status:f.status,succeeded:f.succeeded,failed:f.failed,failedIndexes:f.failedIndexes,results:f.results,coalesced:f.coalesced}}async function B(e,n,l){const s=x(e,n);if(!s.plan)throw new M("INVALID",s.errors.join("; "));if(!s.ok)throw new M("MISSING_PARAMS",`missing: ${s.missing.join(", ")}`);return P(s.plan,l)}export{j as RECIPE_MODES,M as RecipeError,L as dryRunRecipe,x as expandRecipe,N as mapInput,J as recipeParams,P as runPlan,B as runRecipe,S as validateRecipe};

package/record-list.js

@@ -1,110 +1,2 @@
-// A list of records as a person reads it: which order, which ones, and under which heading.
-//
-// The desktop showed 300 rows newest-modified-first with a date and nothing else, and it read
-// as unsorted — twelve rows saying "Sep 12" are indistinguishable, "modified" is not the
-// date a person remembers a chat by, and nothing separated today from last month. The query
-// was right; the reading was impossible. These are the rules that make the same rows
-// legible, kept out of the client because every list of records — the extension's history,
-// a phone's — has to answer the same three questions the same way.
-//
-// Pure: `now` is injected, and a record needs only `{ title, snippet?, updatedAt, createdAt }`.
-
-export const SORT_MODES = Object.freeze(['recent', 'started', 'title']);
-
-export const SORT_LABELS = Object.freeze({
-  recent: 'Recently active',
-  started: 'Date started',
-  title: 'Title A–Z',
-});
-
-const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
-
-/** The timestamp a sort mode reads — modified for `recent`, created for `started`. */
-export function sortStamp(rec, mode = 'recent') {
-  if (mode === 'started') return num(rec?.createdAt) || num(rec?.updatedAt);
-  return num(rec?.updatedAt) || num(rec?.createdAt);
-}
-
-export function sortRecords(items, mode = 'recent') {
-  const list = Array.isArray(items) ? [...items] : [];
-  if (mode === 'title') {
-    return list.sort((a, b) => String(a?.title || '').localeCompare(String(b?.title || ''), undefined, { sensitivity: 'base' }) || sortStamp(b) - sortStamp(a));
-  }
-  const m = SORT_MODES.includes(mode) ? mode : 'recent';
-  return list.sort((a, b) => sortStamp(b, m) - sortStamp(a, m));
-}
-
-/**
- * Keep the rows every word of the query appears in — title or snippet, any order, any case.
- * A query of nothing keeps everything, so a filter box can be bound to it directly.
- */
-export function filterRecords(items, query) {
-  const words = String(query || '').toLowerCase().split(/\s+/).filter(Boolean);
-  const list = Array.isArray(items) ? items : [];
-  if (!words.length) return list;
-  return list.filter((r) => {
-    const hay = `${r?.title || ''}\n${r?.snippet || ''}`.toLowerCase();
-    return words.every((w) => hay.includes(w));
-  });
-}
-
-const DAY = 86_400_000;
-
-function startOfDay(ts) {
-  const d = new Date(ts);
-  d.setHours(0, 0, 0, 0);
-  return d.getTime();
-}
-
-const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
-const DAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
-
-/** Which heading a timestamp files under, relative to `now`. */
-export function dayBucket(ts, now = Date.now()) {
-  const t = num(ts);
-  if (!t) return { key: 'undated', label: 'Undated', order: 9e15 };
-  const today = startOfDay(now);
-  const day = startOfDay(t);
-  const daysAgo = Math.round((today - day) / DAY);
-  if (daysAgo <= 0) return { key: 'today', label: 'Today', order: 0 };
-  if (daysAgo === 1) return { key: 'yesterday', label: 'Yesterday', order: 1 };
-  if (daysAgo < 7) return { key: 'week', label: 'Earlier this week', order: 2 };
-  const d = new Date(t);
-  const n = new Date(now);
-  if (d.getFullYear() === n.getFullYear() && d.getMonth() === n.getMonth()) return { key: 'month', label: 'Earlier this month', order: 3 };
-  const label = d.getFullYear() === n.getFullYear() ? MONTHS[d.getMonth()] : `${MONTHS[d.getMonth()]} ${d.getFullYear()}`;
-  return { key: `m-${d.getFullYear()}-${d.getMonth()}`, label, order: 4 + (n.getFullYear() * 12 + n.getMonth()) - (d.getFullYear() * 12 + d.getMonth()) };
-}
-
-/**
- * The time a row shows, sized to how far away it is: a clock today and yesterday, a weekday
- * this week, a short date after that. Inside a day group the clock is the only thing that
- * tells two rows apart — which is the whole reason the desktop's list looked unsorted.
- */
-export function rowTime(ts, now = Date.now(), { locale = undefined } = {}) {
-  const t = num(ts);
-  if (!t) return '';
-  const b = dayBucket(t, now);
-  const d = new Date(t);
-  if (b.key === 'today' || b.key === 'yesterday') return d.toLocaleTimeString(locale, { hour: 'numeric', minute: '2-digit' });
-  if (b.key === 'week') return DAYS[d.getDay()];
-  const sameYear = d.getFullYear() === new Date(now).getFullYear();
-  return d.toLocaleDateString(locale, { month: 'short', day: 'numeric', ...(sameYear ? {} : { year: 'numeric' }) });
-}
-
-/**
- * Sort, filter and group in one pass: `[{ key, label, items }]`, groups in reading order.
- * With `mode: 'title'` there is one group and no heading, because an alphabetical list has
- * nothing to do with days.
- */
-export function groupRecords(items, { mode = 'recent', query = '', now = Date.now() } = {}) {
-  const sorted = sortRecords(filterRecords(items, query), mode);
-  if (mode === 'title') return sorted.length ? [{ key: 'all', label: '', items: sorted }] : [];
-  const groups = new Map();
-  for (const r of sorted) {
-    const b = dayBucket(sortStamp(r, mode), now);
-    if (!groups.has(b.key)) groups.set(b.key, { key: b.key, label: b.label, order: b.order, items: [] });
-    groups.get(b.key).items.push(r);
-  }
-  return [...groups.values()].sort((a, b) => a.order - b.order).map(({ order, ...g }) => g);
-}
+const f=Object.freeze(["recent","started","title"]),k=Object.freeze({recent:"Recently active",started:"Date started",title:"Title A–Z"}),i=e=>Number.isFinite(Number(e))?Number(e):0;function l(e,t="recent"){return t==="started"?i(e?.createdAt)||i(e?.updatedAt):i(e?.updatedAt)||i(e?.createdAt)}function h(e,t="recent"){const s=Array.isArray(e)?[...e]:[];if(t==="title")return s.sort((o,r)=>String(o?.title||"").localeCompare(String(r?.title||""),void 0,{sensitivity:"base"})||l(r)-l(o));const u=f.includes(t)?t:"recent";return s.sort((o,r)=>l(r,u)-l(o,u))}function p(e,t){const s=String(t||"").toLowerCase().split(/\s+/).filter(Boolean),u=Array.isArray(e)?e:[];return s.length?u.filter(o=>{const r=`${o?.title||""}
+${o?.snippet||""}`.toLowerCase();return s.every(n=>r.includes(n))}):u}const b=864e5;function c(e){const t=new Date(e);return t.setHours(0,0,0,0),t.getTime()}const d=["January","February","March","April","May","June","July","August","September","October","November","December"],m=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];function y(e,t=Date.now()){const s=i(e);if(!s)return{key:"undated",label:"Undated",order:9e15};const u=c(t),o=c(s),r=Math.round((u-o)/b);if(r<=0)return{key:"today",label:"Today",order:0};if(r===1)return{key:"yesterday",label:"Yesterday",order:1};if(r<7)return{key:"week",label:"Earlier this week",order:2};const n=new Date(s),a=new Date(t);if(n.getFullYear()===a.getFullYear()&&n.getMonth()===a.getMonth())return{key:"month",label:"Earlier this month",order:3};const g=n.getFullYear()===a.getFullYear()?d[n.getMonth()]:`${d[n.getMonth()]} ${n.getFullYear()}`;return{key:`m-${n.getFullYear()}-${n.getMonth()}`,label:g,order:4+(a.getFullYear()*12+a.getMonth())-(n.getFullYear()*12+n.getMonth())}}function D(e,t=Date.now(),{locale:s=void 0}={}){const u=i(e);if(!u)return"";const o=y(u,t),r=new Date(u);if(o.key==="today"||o.key==="yesterday")return r.toLocaleTimeString(s,{hour:"numeric",minute:"2-digit"});if(o.key==="week")return m[r.getDay()];const n=r.getFullYear()===new Date(t).getFullYear();return r.toLocaleDateString(s,{month:"short",day:"numeric",...n?{}:{year:"numeric"}})}function A(e,{mode:t="recent",query:s="",now:u=Date.now()}={}){const o=h(p(e,s),t);if(t==="title")return o.length?[{key:"all",label:"",items:o}]:[];const r=new Map;for(const n of o){const a=y(l(n,t),u);r.has(a.key)||r.set(a.key,{key:a.key,label:a.label,order:a.order,items:[]}),r.get(a.key).items.push(n)}return[...r.values()].sort((n,a)=>n.order-a.order).map(({order:n,...a})=>a)}export{k as SORT_LABELS,f as SORT_MODES,y as dayBucket,p as filterRecords,A as groupRecords,D as rowTime,h as sortRecords,l as sortStamp};