@glyphlab/scenario-core 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Subtubes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,17 @@
-# Temporary Holding Version
+# @glyphlab/scenario-core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The scenario engine, without UI. Peer dependencies: `zod`, `@glyphlab/diagram-core`.
+
+```ts
+import { defaultInput, readScenarioFile, runScenario } from '@glyphlab/scenario-core'
+
+const file = readScenarioFile(json)            // { ok, value: { scenarios } } or a typed error
+const graph = { nodes: [{ id: 'a', title: 'Web' }], edges: [{ id: 'e', from: 'a', to: 'b' }] }
+const scenario = file.ok ? file.value.scenarios[0] : undefined
+const trace = scenario && runScenario(graph, scenario, defaultInput(scenario))   // steps, outcome, message
+```
+
+- `runScenario(graph, scenario, input)` is pure: the same graph, scenario and input give the same trace.
+- `validateScenario` / `checkNewScenario` report the steps that point at nodes or edges the graph does not have.
+- `highlightsAt(trace, cursor)` gives what to light up on a diagram at a step (the types are `diagram-core`'s).
+- `scenarioSchema` is the one definition used by the file format and by the createScenario tool.

package/index.d.ts

@@ -0,0 +1,310 @@
+import * as _glyphlab_diagram_core from '@glyphlab/diagram-core';
+import { Highlights, DiagramFile } from '@glyphlab/diagram-core';
+export { EdgeHighlight, Highlights, NodeHighlight } from '@glyphlab/diagram-core';
+import { z } from 'zod';
+
+type Primitive = string | number | boolean;
+type Values = Record<string, Primitive>;
+interface GraphModel {
+    nodes: {
+        id: string;
+        title: string;
+    }[];
+    edges: {
+        id: string;
+        from: string;
+        to: string;
+        label: string;
+    }[];
+}
+interface InputField {
+    name: string;
+    label: string;
+    type: 'text' | 'number' | 'boolean' | 'select';
+    default: Primitive;
+    options?: string[];
+    help?: string;
+    fromChat?: boolean;
+}
+type CompareOp = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains' | 'truthy';
+type Condition = {
+    all: Condition[];
+} | {
+    any: Condition[];
+} | {
+    not: Condition;
+} | {
+    path: string;
+    op: CompareOp;
+    value?: Primitive | Primitive[];
+};
+type Outcome = 'success' | 'failure' | 'blocked' | 'stopped';
+interface EndSpec {
+    outcome: Exclude<Outcome, 'stopped'>;
+    message: string;
+}
+interface DeriveRule {
+    contains: string[];
+    value: Primitive;
+}
+interface Derive {
+    from: string;
+    rules: DeriveRule[];
+    default: Primitive;
+}
+type Effect = {
+    set: string;
+    value: Primitive;
+} | {
+    set: string;
+    add: number;
+} | {
+    set: string;
+    derive: Derive;
+    ai?: boolean;
+};
+interface Transition {
+    to?: string;
+    end?: EndSpec;
+    when?: Condition;
+    label?: string;
+}
+interface Call {
+    to: string;
+    title: string;
+    detail?: string;
+    when?: Condition;
+}
+interface StepRule {
+    node: string;
+    title: string;
+    detail?: string;
+    effects?: Effect[];
+    calls?: Call[];
+    next?: Transition[];
+    end?: EndSpec;
+}
+interface Preset {
+    name: string;
+    values: Values;
+}
+interface Scenario {
+    id: string;
+    title: string;
+    description: string;
+    triggers?: string[];
+    inputs: InputField[];
+    presets?: Preset[];
+    initialState?: Values;
+    start: string;
+    steps: Record<string, StepRule>;
+}
+interface ScenarioFile {
+    schemaVersion: 1;
+    scenarios: Scenario[];
+}
+type StepKind = 'enter' | 'call' | 'end';
+interface StateChange {
+    key: string;
+    from?: Primitive;
+    to: Primitive;
+    ai?: boolean;
+}
+interface DecisionOption {
+    label: string;
+    taken: boolean;
+}
+interface TraceStep {
+    index: number;
+    kind: StepKind;
+    stepId: string;
+    nodeId: string;
+    nodeTitle: string;
+    edgeId?: string;
+    fromNodeId?: string;
+    title: string;
+    detail?: string;
+    changes: StateChange[];
+    state: Values;
+    decision?: {
+        options: DecisionOption[];
+    };
+    outcome?: Outcome;
+    warnings: string[];
+}
+interface Trace {
+    scenarioId: string;
+    scenarioTitle: string;
+    input: Values;
+    steps: TraceStep[];
+    outcome: Outcome;
+    message: string;
+}
+interface ScenarioIssue {
+    severity: 'error' | 'warning';
+    message: string;
+}
+interface ScenarioAttachment {
+    scenarioId: string;
+    scenarioVersion?: string;
+    engineVersion?: number;
+    input: Values;
+    result?: {
+        outcome: Outcome;
+        message: string;
+        steps: number;
+    };
+}
+
+declare function edgeBetween(graph: GraphModel, from: string, to: string): {
+    id: string;
+    from: string;
+    to: string;
+    label: string;
+} | undefined;
+declare function runScenario(graph: GraphModel, scenario: Scenario, input: Values): Trace;
+declare function defaultInput(scenario: Scenario): Values;
+
+type NewScenarioCheck = {
+    ok: true;
+    issues: ScenarioIssue[];
+    preview: {
+        outcome: 'success' | 'failure' | 'blocked' | 'stopped';
+        message: string;
+        steps: number;
+    };
+} | {
+    ok: false;
+    error: 'duplicate-id' | 'unknown-nodes' | 'invalid';
+    message: string;
+    issues?: ScenarioIssue[];
+};
+declare function checkNewScenario(scenario: Scenario, graph: GraphModel, existingIds: string[]): NewScenarioCheck;
+
+declare function validateScenario(scenario: Scenario, graph: GraphModel): ScenarioIssue[];
+
+declare function highlightsAt(trace: Trace, cursor: number): Highlights;
+
+type ScenarioCondition = {
+    all: ScenarioCondition[];
+} | {
+    any: ScenarioCondition[];
+} | {
+    not: ScenarioCondition;
+} | {
+    path: string;
+    op: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains' | 'truthy';
+    value?: string | number | boolean | (string | number | boolean)[];
+};
+declare const conditionSchema: z.ZodType<ScenarioCondition>;
+declare const scenarioSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    inputs: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodString;
+        type: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            text: "text";
+            select: "select";
+        }>;
+        default: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        help: z.ZodOptional<z.ZodString>;
+        fromChat: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    presets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strict>>>;
+    initialState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    start: z.ZodString;
+    steps: z.ZodRecord<z.ZodString, z.ZodObject<{
+        node: z.ZodString;
+        title: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+        effects: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            set: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        }, z.core.$strict>, z.ZodObject<{
+            set: z.ZodString;
+            add: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            set: z.ZodString;
+            derive: z.ZodObject<{
+                from: z.ZodString;
+                rules: z.ZodArray<z.ZodObject<{
+                    contains: z.ZodArray<z.ZodString>;
+                    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+                }, z.core.$strict>>;
+                default: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            }, z.core.$strict>;
+            ai: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>]>>>;
+        calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            to: z.ZodString;
+            title: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            when: z.ZodOptional<z.ZodType<ScenarioCondition, unknown, z.core.$ZodTypeInternals<ScenarioCondition, unknown>>>;
+        }, z.core.$strict>>>;
+        next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            to: z.ZodOptional<z.ZodString>;
+            end: z.ZodOptional<z.ZodObject<{
+                outcome: z.ZodEnum<{
+                    success: "success";
+                    failure: "failure";
+                    blocked: "blocked";
+                }>;
+                message: z.ZodString;
+            }, z.core.$strict>>;
+            when: z.ZodOptional<z.ZodType<ScenarioCondition, unknown, z.core.$ZodTypeInternals<ScenarioCondition, unknown>>>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        end: z.ZodOptional<z.ZodObject<{
+            outcome: z.ZodEnum<{
+                success: "success";
+                failure: "failure";
+                blocked: "blocked";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type ScenarioDraft = z.infer<typeof scenarioSchema>;
+
+declare const SCENARIO_SCHEMA_VERSION = 1;
+
+declare const scenarioFileV1Schema: z.ZodType<ScenarioFile>;
+declare const scenarioFileSchema: z.ZodType<ScenarioFile, unknown, z.core.$ZodTypeInternals<ScenarioFile, unknown>>;
+declare const scenarioFileFormat: _glyphlab_diagram_core.Format<ScenarioFile>;
+declare function parseScenarioFile(input: unknown): ScenarioFile;
+declare function readScenarioFile(input: unknown): _glyphlab_diagram_core.ReadResult<ScenarioFile>;
+
+declare const ENGINE_VERSION = 1;
+declare function scenarioVersion(scenario: Scenario): string;
+
+declare const DESIGN_EXPORT_FORMAT = "glyph-design";
+declare const DESIGN_EXPORT_VERSION = 1;
+interface DesignExport {
+    format: typeof DESIGN_EXPORT_FORMAT;
+    schemaVersion: typeof DESIGN_EXPORT_VERSION;
+    diagram: DiagramFile;
+    scenarios: Scenario[];
+}
+declare function writeDesignExport(diagram: DiagramFile, scenarios: Scenario[]): string;
+type ReadDesignExport = {
+    ok: true;
+    diagram: DiagramFile;
+    scenarios: Scenario[];
+    warnings: string[];
+} | {
+    ok: false;
+    reason: string;
+};
+declare function readDesignExport(text: string): ReadDesignExport;
+
+export { DESIGN_EXPORT_FORMAT, DESIGN_EXPORT_VERSION, ENGINE_VERSION, SCENARIO_SCHEMA_VERSION, checkNewScenario, conditionSchema, defaultInput, edgeBetween, highlightsAt, parseScenarioFile, readDesignExport, readScenarioFile, runScenario, scenarioFileFormat, scenarioFileSchema, scenarioFileV1Schema, scenarioSchema, scenarioVersion, validateScenario, writeDesignExport };
+export type { Call, CompareOp, Condition, DecisionOption, Derive, DeriveRule, DesignExport, Effect, EndSpec, GraphModel, InputField, NewScenarioCheck, Outcome, Preset, Primitive, ReadDesignExport, Scenario, ScenarioAttachment, ScenarioCondition, ScenarioDraft, ScenarioFile, ScenarioIssue, StateChange, StepKind, StepRule, Trace, TraceStep, Transition, Values };

package/index.js

@@ -0,0 +1,535 @@
+// packages/scenario-core/src/conditions.ts
+function resolvePath(scope, path) {
+  const [root, ...rest] = path.split(".");
+  const key = rest.join(".");
+  if (root === "input") return scope.input[key];
+  if (root === "state") return scope.state[key];
+  return void 0;
+}
+function compare(op, left, right) {
+  switch (op) {
+    case "truthy":
+      return Boolean(left);
+    case "eq":
+      return left === right;
+    case "ne":
+      return left !== right;
+    case "gt":
+      return Number(left) > Number(right);
+    case "gte":
+      return Number(left) >= Number(right);
+    case "lt":
+      return Number(left) < Number(right);
+    case "lte":
+      return Number(left) <= Number(right);
+    case "in":
+      return Array.isArray(right) && left !== void 0 && right.includes(left);
+    case "contains":
+      return typeof right === "string" && String(left ?? "").toLowerCase().includes(right.toLowerCase());
+    default:
+      return false;
+  }
+}
+function evaluate(condition, scope) {
+  if ("all" in condition) return condition.all.every((c) => evaluate(c, scope));
+  if ("any" in condition) return condition.any.some((c) => evaluate(c, scope));
+  if ("not" in condition) return !evaluate(condition.not, scope);
+  return compare(condition.op, resolvePath(scope, condition.path), condition.value);
+}
+function show(value) {
+  if (Array.isArray(value)) return `[${value.map(show).join(", ")}]`;
+  return typeof value === "string" ? `\u201C${value}\u201D` : String(value);
+}
+var OP_TEXT = {
+  eq: "is",
+  ne: "is not",
+  gt: ">",
+  gte: "\u2265",
+  lt: "<",
+  lte: "\u2264",
+  in: "is one of",
+  contains: "contains"
+};
+function describeCondition(condition) {
+  if ("all" in condition) return condition.all.map(describeCondition).join(" and ");
+  if ("any" in condition) return condition.any.map(describeCondition).join(" or ");
+  if ("not" in condition) return `not (${describeCondition(condition.not)})`;
+  const name = condition.path.split(".").slice(1).join(".");
+  if (condition.op === "truthy") return `${name} is on`;
+  return `${name} ${OP_TEXT[condition.op]} ${show(condition.value)}`;
+}
+function interpolate(text, scope) {
+  return text.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (_, path) => String(resolvePath(scope, path) ?? ""));
+}
+
+// packages/scenario-core/src/engine.ts
+var MAX_STEPS = 60;
+function edgeBetween(graph, from, to) {
+  return graph.edges.find((e) => e.from === from && e.to === to);
+}
+function applyEffects(effects, input, state) {
+  const changes = [];
+  for (const effect of effects) {
+    const scope = { input, state };
+    let value;
+    let ai = false;
+    if ("derive" in effect) {
+      const source = String(resolvePath(scope, effect.derive.from) ?? "").toLowerCase();
+      const rule = effect.derive.rules.find((r) => r.contains.some((word) => source.includes(word.toLowerCase())));
+      value = rule ? rule.value : effect.derive.default;
+      ai = effect.ai === true;
+    } else if ("add" in effect) {
+      value = Number(state[effect.set] ?? 0) + effect.add;
+    } else {
+      value = typeof effect.value === "string" ? interpolate(effect.value, scope) : effect.value;
+    }
+    if (state[effect.set] !== value) {
+      changes.push({ key: effect.set, from: state[effect.set], to: value, ai: ai || void 0 });
+      state[effect.set] = value;
+    }
+  }
+  return changes;
+}
+function runScenario(graph, scenario, input) {
+  const titles = new Map(graph.nodes.map((n) => [n.id, n.title]));
+  const nodeTitle = (id) => titles.get(id) ?? id;
+  const state = { ...scenario.initialState };
+  const steps = [];
+  let outcome = "stopped";
+  let message = "";
+  const scope = () => ({ input, state });
+  const push = (step) => steps.push({ ...step, index: steps.length, nodeTitle: nodeTitle(step.nodeId), state: { ...state } });
+  const end = (stepId, nodeId, result) => {
+    outcome = result.outcome;
+    message = interpolate(result.message, scope());
+    push({ kind: "end", stepId, nodeId, title: message, outcome, changes: [], warnings: [] });
+  };
+  let current = scenario.start;
+  let incoming = {};
+  while (current !== void 0) {
+    const rule = scenario.steps[current];
+    if (!rule) {
+      outcome = "stopped";
+      message = `Step \u201C${current}\u201D is not defined.`;
+      break;
+    }
+    if (steps.length >= MAX_STEPS) {
+      end(current, rule.node, { outcome: "stopped", message: `Stopped after ${MAX_STEPS} steps; the scenario may be looping.` });
+      break;
+    }
+    const changes = applyEffects(rule.effects ?? [], input, state);
+    const warnings = [];
+    if (incoming.from && !incoming.edgeId) {
+      warnings.push(`The diagram has no edge from \u201C${nodeTitle(incoming.from)}\u201D to \u201C${nodeTitle(rule.node)}\u201D.`);
+    }
+    push({
+      kind: "enter",
+      stepId: current,
+      nodeId: rule.node,
+      edgeId: incoming.edgeId,
+      fromNodeId: incoming.from,
+      title: interpolate(rule.title, scope()),
+      detail: rule.detail ? interpolate(rule.detail, scope()) : void 0,
+      changes,
+      warnings
+    });
+    const enterIndex = steps.length - 1;
+    for (const call of rule.calls ?? []) {
+      if (call.when && !evaluate(call.when, scope())) continue;
+      const edge2 = edgeBetween(graph, rule.node, call.to);
+      push({
+        kind: "call",
+        stepId: current,
+        nodeId: call.to,
+        edgeId: edge2?.id,
+        fromNodeId: rule.node,
+        title: interpolate(call.title, scope()),
+        detail: call.detail ? interpolate(call.detail, scope()) : void 0,
+        changes: [],
+        warnings: edge2 ? [] : [`The diagram has no edge from \u201C${nodeTitle(rule.node)}\u201D to \u201C${nodeTitle(call.to)}\u201D.`]
+      });
+    }
+    if (rule.end) {
+      end(current, rule.node, rule.end);
+      break;
+    }
+    const next = rule.next ?? [];
+    if (next.length === 0) {
+      end(current, rule.node, { outcome: "success", message: "The flow finished." });
+      break;
+    }
+    const taken = next.findIndex((t) => !t.when || evaluate(t.when, scope()));
+    if (next.length > 1) {
+      steps[enterIndex].decision = {
+        options: next.map((t, i) => ({
+          label: t.label ?? (t.when ? describeCondition(t.when) : "otherwise"),
+          taken: i === taken
+        }))
+      };
+    }
+    if (taken < 0) {
+      end(current, rule.node, { outcome: "stopped", message: "No branch matched here, so the run stopped." });
+      break;
+    }
+    const transition = next[taken];
+    if (transition.end) {
+      end(current, rule.node, transition.end);
+      break;
+    }
+    const target = transition.to !== void 0 ? scenario.steps[transition.to] : void 0;
+    const edge = target ? edgeBetween(graph, rule.node, target.node) : void 0;
+    incoming = { edgeId: edge?.id, from: rule.node };
+    current = transition.to;
+  }
+  return { scenarioId: scenario.id, scenarioTitle: scenario.title, input, steps, outcome, message };
+}
+function defaultInput(scenario) {
+  return Object.fromEntries(scenario.inputs.map((f) => [f.name, f.default]));
+}
+
+// packages/scenario-core/src/validate.ts
+function validateScenario(scenario, graph) {
+  const issues = [];
+  const nodeIds = new Set(graph.nodes.map((n) => n.id));
+  for (const [stepId, step] of Object.entries(scenario.steps)) {
+    if (!nodeIds.has(step.node)) {
+      issues.push({ severity: "error", message: `Step \u201C${stepId}\u201D refers to a node that is not in the diagram: ${step.node}` });
+    }
+    for (const call of step.calls ?? []) {
+      if (nodeIds.has(step.node) && nodeIds.has(call.to) && !edgeBetween(graph, step.node, call.to)) {
+        issues.push({ severity: "warning", message: `No edge from ${step.node} to ${call.to} for the call in \u201C${stepId}\u201D.` });
+      }
+    }
+    for (const next of step.next ?? []) {
+      const target = next.to !== void 0 ? scenario.steps[next.to] : void 0;
+      if (target && nodeIds.has(step.node) && nodeIds.has(target.node) && !edgeBetween(graph, step.node, target.node)) {
+        issues.push({ severity: "warning", message: `No edge from ${step.node} to ${target.node} for the branch in \u201C${stepId}\u201D.` });
+      }
+    }
+  }
+  return issues;
+}
+
+// packages/scenario-core/src/check.ts
+var MAX_LISTED_NODES = 40;
+function checkNewScenario(scenario, graph, existingIds) {
+  if (existingIds.includes(scenario.id)) {
+    return {
+      ok: false,
+      error: "duplicate-id",
+      message: `This design already has a scenario with the id "${scenario.id}". Use a different id. Existing ids: ${existingIds.join(", ")}.`
+    };
+  }
+  const inputProblems = checkInputs(scenario);
+  if (inputProblems.length > 0) {
+    return { ok: false, error: "invalid", message: `The scenario's inputs are not usable: ${inputProblems.join(" ")}` };
+  }
+  const unknown = unknownNodes(scenario, graph);
+  if (unknown.length > 0) {
+    const byTitle = new Map(graph.nodes.map((n) => [n.title.trim().toLowerCase(), n.id]));
+    const lines = unknown.map((ref) => {
+      const guess = byTitle.get(ref.trim().toLowerCase());
+      return guess ? `"${ref}" is a title, not an id; use "${guess}".` : `"${ref}" is not a node in the diagram.`;
+    });
+    const known = graph.nodes.slice(0, MAX_LISTED_NODES).map((n) => `${n.id} (${n.title})`).join(", ");
+    const more = graph.nodes.length > MAX_LISTED_NODES ? `, and ${graph.nodes.length - MAX_LISTED_NODES} more (call getDiagram)` : "";
+    return {
+      ok: false,
+      error: "unknown-nodes",
+      message: `Steps must happen at nodes that exist. ${lines.join(" ")} Nodes in the diagram: ${known || "none"}${more}.`
+    };
+  }
+  const trace = runScenario(graph, scenario, defaultInput(scenario));
+  if (trace.outcome === "stopped") {
+    return { ok: false, error: "invalid", message: `A trial run with the default inputs did not finish: ${trace.message} Make sure every step either ends or has a branch that always applies (a last one with no "when").` };
+  }
+  const issues = [...validateScenario(scenario, graph).filter((i) => i.severity === "warning"), ...lint(scenario)];
+  return { ok: true, issues, preview: { outcome: trace.outcome, message: trace.message, steps: trace.steps.length } };
+}
+function checkInputs(scenario) {
+  const problems = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of scenario.inputs) {
+    if (seen.has(field.name)) problems.push(`Two inputs are called "${field.name}".`);
+    seen.add(field.name);
+    const kind = typeof field.default;
+    if (field.type === "number" && kind !== "number") problems.push(`Input "${field.name}" is a number, so its default must be a number.`);
+    if (field.type === "boolean" && kind !== "boolean") problems.push(`Input "${field.name}" is a boolean, so its default must be true or false.`);
+    if (field.type === "text" && kind !== "string") problems.push(`Input "${field.name}" is text, so its default must be a string.`);
+    if (field.type === "select") {
+      if (!field.options || field.options.length === 0) problems.push(`Input "${field.name}" is a select, so it needs "options".`);
+      else if (!field.options.includes(String(field.default))) problems.push(`The default of "${field.name}" must be one of its options.`);
+    }
+  }
+  return problems;
+}
+function unknownNodes(scenario, graph) {
+  const ids = new Set(graph.nodes.map((n) => n.id));
+  const unknown = [];
+  const check = (ref) => {
+    if (!ids.has(ref) && !unknown.includes(ref)) unknown.push(ref);
+  };
+  for (const step of Object.values(scenario.steps)) {
+    check(step.node);
+    for (const call of step.calls ?? []) check(call.to);
+  }
+  return unknown;
+}
+function lint(scenario) {
+  const issues = [];
+  const warn = (message) => issues.push({ severity: "warning", message });
+  const inputNames = new Set(scenario.inputs.map((f) => f.name));
+  const stateNames = new Set(Object.keys(scenario.initialState ?? {}));
+  for (const step of Object.values(scenario.steps)) for (const effect of step.effects ?? []) stateNames.add(effect.set);
+  const checkRef = (ref, where) => {
+    const [root, ...rest] = ref.split(".");
+    const name = rest.join(".");
+    if (root === "input" && !inputNames.has(name)) warn(`${where} reads input.${name}, but the scenario has no input called "${name}".`);
+    if (root === "state" && !stateNames.has(name)) warn(`${where} reads state.${name}, but no step sets it and it is not in initialState.`);
+  };
+  const conditionPaths = (condition) => {
+    if (typeof condition !== "object" || condition === null) return [];
+    const c = condition;
+    if (Array.isArray(c.all)) return c.all.flatMap(conditionPaths);
+    if (Array.isArray(c.any)) return c.any.flatMap(conditionPaths);
+    if ("not" in c) return conditionPaths(c.not);
+    return typeof c.path === "string" ? [c.path] : [];
+  };
+  for (const [stepId, step] of Object.entries(scenario.steps)) {
+    const where = `Step \u201C${stepId}\u201D`;
+    for (const next of step.next ?? []) for (const path of conditionPaths(next.when)) checkRef(path, where);
+    for (const call of step.calls ?? []) for (const path of conditionPaths(call.when)) checkRef(path, where);
+    for (const effect of step.effects ?? []) if ("derive" in effect) checkRef(effect.derive.from, where);
+  }
+  for (const text of strings(scenario)) {
+    for (const match of text.matchAll(/\{\{\s*([\w.]+)\s*\}\}/g)) checkRef(match[1], "The text");
+  }
+  for (const preset of scenario.presets ?? []) {
+    for (const key of Object.keys(preset.values)) {
+      if (!inputNames.has(key)) warn(`Preset \u201C${preset.name}\u201D sets "${key}", which is not an input.`);
+    }
+  }
+  const reached = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (reached.has(id) || !scenario.steps[id]) return;
+    reached.add(id);
+    for (const next of scenario.steps[id].next ?? []) if (next.to !== void 0) visit(next.to);
+  };
+  visit(scenario.start);
+  for (const id of Object.keys(scenario.steps)) if (!reached.has(id)) warn(`Step \u201C${id}\u201D can never be reached from the start.`);
+  return dedupe(issues);
+}
+function strings(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) return value.flatMap(strings);
+  if (typeof value === "object" && value !== null) return Object.values(value).flatMap(strings);
+  return [];
+}
+function dedupe(issues) {
+  const seen = /* @__PURE__ */ new Set();
+  return issues.filter((i) => seen.has(i.message) ? false : (seen.add(i.message), true));
+}
+
+// packages/scenario-core/src/highlights.ts
+var OUTCOME_HIGHLIGHT = { success: "success", failure: "failure", blocked: "blocked" };
+function highlightsAt(trace, cursor) {
+  const nodes = {};
+  const edges = {};
+  for (let i = 0; i <= cursor && i < trace.steps.length; i++) {
+    const step = trace.steps[i];
+    nodes[step.nodeId] = "visited";
+    if (step.edgeId) edges[step.edgeId] = "visited";
+  }
+  const current = trace.steps[cursor];
+  if (current) {
+    const outcome = current.kind === "end" ? current.outcome : void 0;
+    nodes[current.nodeId] = outcome && outcome !== "stopped" ? OUTCOME_HIGHLIGHT[outcome] : "active";
+    if (current.edgeId) edges[current.edgeId] = "active";
+  }
+  return { nodes, edges };
+}
+
+// packages/scenario-core/src/scenarioSchema.ts
+import { z } from "zod";
+var idSchema = z.string().min(1);
+var primitive = z.union([z.string(), z.number(), z.boolean()]);
+var pathSchema = z.string().regex(/^(input|state)\.[\w]+$/, "Use input.<name> or state.<name>").describe('Where to read a value: "input.<name>" is something the user entered; "state.<name>" is something an earlier step set.');
+var outcomeSchema = z.enum(["success", "failure", "blocked"]);
+var conditionSchema = z.lazy(
+  () => z.union([
+    z.strictObject({ all: z.array(conditionSchema) }),
+    z.strictObject({ any: z.array(conditionSchema) }),
+    z.strictObject({ not: conditionSchema }),
+    z.strictObject({
+      path: pathSchema,
+      op: z.enum(["eq", "ne", "gt", "gte", "lt", "lte", "in", "contains", "truthy"]).describe('"eq"/"ne" compare for equality; "gt"/"gte"/"lt"/"lte" compare numbers; "in" needs a list as value; "contains" is a case-insensitive text match; "truthy" needs no value.'),
+      value: z.union([primitive, z.array(primitive)]).optional()
+    })
+  ])
+).describe("A test on the input or the run state. Combine tests with {all:[...]}, {any:[...]} or {not:...}.");
+var endSchema = z.strictObject({
+  outcome: outcomeSchema.describe('How the run ended: "success", "failure" (something went wrong), or "blocked" (it was refused or had to stop).'),
+  message: z.string().min(1).describe("One sentence saying what happened. May use {{input.x}} and {{state.x}}.")
+}).describe("Ends the run here.");
+var effectSchema = z.union([
+  z.strictObject({ set: idSchema, value: primitive }),
+  z.strictObject({ set: idSchema, add: z.number() }),
+  z.strictObject({
+    set: idSchema,
+    derive: z.strictObject({
+      from: pathSchema,
+      rules: z.array(z.strictObject({ contains: z.array(z.string().min(1)).min(1), value: primitive })).describe("Tried in order; the first whose words appear in the text wins."),
+      default: primitive
+    }),
+    ai: z.boolean().optional().describe("Mark the result as something the assistant would work out, in the display.")
+  })
+]).describe("Changes the run state when the step happens. {set, value} stores a value (text may use {{input.x}}/{{state.x}}); {set, add} adds to a number; {set, derive} reads free text and picks a value by keyword.");
+var transitionSchema = z.strictObject({
+  to: idSchema.optional().describe('The id of the next step (a key of "steps").'),
+  end: endSchema.optional(),
+  when: conditionSchema.optional().describe('Take this branch only if the condition holds. Branches are tried in order, so put a branch with no "when" last as the fallback.'),
+  label: z.string().optional().describe("A short label for the branch, shown where the choice was made.")
+}).refine((t) => t.to !== void 0 !== (t.end !== void 0), 'A branch needs exactly one of "to" or "end"').describe('A way forward from a step: either "to" another step, or "end" the run.');
+var stepSchema = z.strictObject({
+  node: idSchema.describe("The id of the diagram node where this step happens. Use ids from getDiagram, never titles."),
+  title: z.string().min(1).describe("What happens here, as a short sentence. May use {{input.x}} and {{state.x}}."),
+  detail: z.string().optional(),
+  effects: z.array(effectSchema).optional(),
+  calls: z.array(
+    z.strictObject({
+      to: idSchema.describe("The id of a diagram node that this node calls and gets an answer from straight away (a lookup, a tool). Ideally an edge goes from this node to it."),
+      title: z.string().min(1),
+      detail: z.string().optional(),
+      when: conditionSchema.optional()
+    })
+  ).optional().describe("Side trips to other nodes that return immediately; they show on the diagram but do not move the flow."),
+  next: z.array(transitionSchema).optional().describe('Where to go after this step. With none (and no "end"), the run ends as a success.'),
+  end: endSchema.optional().describe('Ends the run at this step, instead of "next".')
+}).describe("One step of the scenario, at one diagram node.");
+var inputSchema = z.strictObject({
+  name: z.string().regex(/^\w+$/).describe('The name used in "input.<name>" and {{input.<name>}}. Letters, digits and underscore.'),
+  label: z.string().min(1).describe("What the person sees next to the field."),
+  type: z.enum(["text", "number", "boolean", "select"]),
+  default: primitive.describe("The value used when the person does not change it. Must suit the type."),
+  options: z.array(z.string()).optional().describe('The choices, for type "select".'),
+  help: z.string().optional(),
+  fromChat: z.boolean().optional().describe("Fill this field from what the person wrote in the chat when the scenario is proposed.")
+});
+var scenarioSchema = z.strictObject({
+  id: idSchema.describe('A short unique id, lowercase with dashes, for example "refund-declined". Not already used by another scenario in the design.'),
+  title: z.string().min(1).describe("The name shown in the scenario list."),
+  description: z.string().describe("One or two sentences on what the scenario shows."),
+  triggers: z.array(z.string().min(1)).optional().describe("Words that make the chat suggest this scenario."),
+  inputs: z.array(inputSchema).describe("What the person can vary before a run. May be empty."),
+  presets: z.array(z.strictObject({ name: z.string().min(1), values: z.record(z.string(), primitive) })).optional().describe("Named sets of input values, for quick choices."),
+  initialState: z.record(z.string(), primitive).optional().describe('Starting values of the run state, read as "state.<name>".'),
+  start: idSchema.describe('The id of the first step: a key of "steps".'),
+  steps: z.record(z.string(), stepSchema).describe('The steps, by id. Branches and "start" refer to these ids.')
+}).superRefine((scenario, ctx) => {
+  const ids = new Set(Object.keys(scenario.steps));
+  if (!ids.has(scenario.start)) {
+    ctx.addIssue({ code: "custom", path: ["start"], message: `Start step "${scenario.start}" is not defined` });
+  }
+  for (const [stepId, step] of Object.entries(scenario.steps)) {
+    step.next?.forEach((t, i) => {
+      if (t.to !== void 0 && !ids.has(t.to)) {
+        ctx.addIssue({ code: "custom", path: ["steps", stepId, "next", i, "to"], message: `Unknown step "${t.to}"` });
+      }
+    });
+  }
+}).describe("A scripted walk through the design: steps at diagram nodes, joined by branches, ending with an outcome.");
+
+// packages/scenario-core/src/schema.ts
+import { z as z2 } from "zod";
+import { defineFormat, readVersioned, readVersionedOrThrow } from "@glyphlab/diagram-core/versioning";
+var SCENARIO_SCHEMA_VERSION = 1;
+var scenarioFileV1Schema = z2.strictObject({
+  schemaVersion: z2.literal(SCENARIO_SCHEMA_VERSION),
+  scenarios: z2.array(scenarioSchema)
+});
+var scenarioFileSchema = scenarioFileV1Schema;
+var scenarioFileFormat = defineFormat({
+  name: "scenario file",
+  history: [{ version: SCENARIO_SCHEMA_VERSION, schema: scenarioFileV1Schema }]
+});
+function parseScenarioFile(input) {
+  return readVersionedOrThrow(scenarioFileFormat, input);
+}
+function readScenarioFile(input) {
+  return readVersioned(scenarioFileFormat, input);
+}
+
+// packages/scenario-core/src/version.ts
+var ENGINE_VERSION = 1;
+function stable(value) {
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+  if (typeof value === "object" && value !== null) {
+    const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stable(v)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function scenarioVersion(scenario) {
+  const text = stable(scenario);
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+
+// packages/scenario-core/src/designExport.ts
+import { readDiagram, serializeDiagram } from "@glyphlab/diagram-core";
+var DESIGN_EXPORT_FORMAT = "glyph-design";
+var DESIGN_EXPORT_VERSION = 1;
+function writeDesignExport(diagram, scenarios) {
+  const file = { format: DESIGN_EXPORT_FORMAT, schemaVersion: DESIGN_EXPORT_VERSION, diagram: JSON.parse(serializeDiagram(diagram)), scenarios };
+  return `${JSON.stringify(file, null, 2)}
+`;
+}
+function readDesignExport(text) {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    return { ok: false, reason: "The file is not valid JSON." };
+  }
+  if (typeof data !== "object" || data === null) return { ok: false, reason: "This is not a Glyph design file." };
+  const file = data;
+  if (file.format !== DESIGN_EXPORT_FORMAT) return { ok: false, reason: "This is not a Glyph design file." };
+  if (file.schemaVersion !== DESIGN_EXPORT_VERSION) return { ok: false, reason: `schemaVersion ${String(file.schemaVersion)} is not supported (use ${DESIGN_EXPORT_VERSION}).` };
+  const diagram = readDiagram(file.diagram);
+  if (!diagram.ok) return { ok: false, reason: "The diagram in this file could not be read." };
+  const warnings = [...diagram.warnings];
+  const list = Array.isArray(file.scenarios) ? file.scenarios : [];
+  const scenarios = list.flatMap((item) => {
+    const parsed = scenarioSchema.safeParse(item);
+    return parsed.success ? [parsed.data] : [];
+  });
+  if (scenarios.length < list.length) warnings.push("Some scenarios in this file could not be read and were left out.");
+  return { ok: true, diagram: diagram.value, scenarios, warnings };
+}
+export {
+  DESIGN_EXPORT_FORMAT,
+  DESIGN_EXPORT_VERSION,
+  ENGINE_VERSION,
+  SCENARIO_SCHEMA_VERSION,
+  checkNewScenario,
+  conditionSchema,
+  defaultInput,
+  edgeBetween,
+  highlightsAt,
+  parseScenarioFile,
+  readDesignExport,
+  readScenarioFile,
+  runScenario,
+  scenarioFileFormat,
+  scenarioFileSchema,
+  scenarioFileV1Schema,
+  scenarioSchema,
+  scenarioVersion,
+  validateScenario,
+  writeDesignExport
+};
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/conditions.ts","../src/engine.ts","../src/validate.ts","../src/check.ts","../src/highlights.ts","../src/scenarioSchema.ts","../src/schema.ts","../src/version.ts","../src/designExport.ts"],"sourcesContent":["import type { Condition, Primitive, Values } from './types'\n\nexport interface Scope {\n  input: Values\n  state: Values\n}\n\nexport function resolvePath(scope: Scope, path: string): Primitive | undefined {\n  const [root, ...rest] = path.split('.')\n  const key = rest.join('.')\n  if (root === 'input') return scope.input[key]\n  if (root === 'state') return scope.state[key]\n  return undefined\n}\n\nfunction compare(op: string, left: Primitive | undefined, right: Primitive | Primitive[] | undefined): boolean {\n  switch (op) {\n    case 'truthy':\n      return Boolean(left)\n    case 'eq':\n      return left === right\n    case 'ne':\n      return left !== right\n    case 'gt':\n      return Number(left) > Number(right)\n    case 'gte':\n      return Number(left) >= Number(right)\n    case 'lt':\n      return Number(left) < Number(right)\n    case 'lte':\n      return Number(left) <= Number(right)\n    case 'in':\n      return Array.isArray(right) && left !== undefined && right.includes(left)\n    case 'contains':\n      return typeof right === 'string' && String(left ?? '').toLowerCase().includes(right.toLowerCase())\n    default:\n      return false\n  }\n}\n\nexport function evaluate(condition: Condition, scope: Scope): boolean {\n  if ('all' in condition) return condition.all.every((c) => evaluate(c, scope))\n  if ('any' in condition) return condition.any.some((c) => evaluate(c, scope))\n  if ('not' in condition) return !evaluate(condition.not, scope)\n  return compare(condition.op, resolvePath(scope, condition.path), condition.value)\n}\n\nfunction show(value: Primitive | Primitive[] | undefined): string {\n  if (Array.isArray(value)) return `[${value.map(show).join(', ')}]`\n  return typeof value === 'string' ? `“${value}”` : String(value)\n}\n\nconst OP_TEXT: Record<string, string> = {\n  eq: 'is',\n  ne: 'is not',\n  gt: '>',\n  gte: '≥',\n  lt: '<',\n  lte: '≤',\n  in: 'is one of',\n  contains: 'contains',\n}\n\n// Human-readable form of a condition, used to label branches that have no label.\nexport function describeCondition(condition: Condition): string {\n  if ('all' in condition) return condition.all.map(describeCondition).join(' and ')\n  if ('any' in condition) return condition.any.map(describeCondition).join(' or ')\n  if ('not' in condition) return `not (${describeCondition(condition.not)})`\n  const name = condition.path.split('.').slice(1).join('.')\n  if (condition.op === 'truthy') return `${name} is on`\n  return `${name} ${OP_TEXT[condition.op]} ${show(condition.value)}`\n}\n\n// Replaces {{input.x}} and {{state.x}}; unknown paths become empty text.\nexport function interpolate(text: string, scope: Scope): string {\n  return text.replace(/\\{\\{\\s*([\\w.]+)\\s*\\}\\}/g, (_, path: string) => String(resolvePath(scope, path) ?? ''))\n}\n","import { describeCondition, evaluate, interpolate, resolvePath } from './conditions'\nimport type { Scope } from './conditions'\nimport type {\n  Effect,\n  EndSpec,\n  GraphModel,\n  Outcome,\n  Scenario,\n  StateChange,\n  StepRule,\n  Trace,\n  TraceStep,\n  Transition,\n  Values,\n} from './types'\n\n// Guards against scenarios that loop forever.\nconst MAX_STEPS = 60\n\nexport function edgeBetween(graph: GraphModel, from: string, to: string) {\n  return graph.edges.find((e) => e.from === from && e.to === to)\n}\n\nfunction applyEffects(effects: Effect[], input: Values, state: Values): StateChange[] {\n  const changes: StateChange[] = []\n\n  for (const effect of effects) {\n    const scope: Scope = { input, state }\n    let value: StateChange['to']\n    let ai = false\n\n    if ('derive' in effect) {\n      const source = String(resolvePath(scope, effect.derive.from) ?? '').toLowerCase()\n      const rule = effect.derive.rules.find((r) => r.contains.some((word) => source.includes(word.toLowerCase())))\n      value = rule ? rule.value : effect.derive.default\n      ai = effect.ai === true\n    } else if ('add' in effect) {\n      value = Number(state[effect.set] ?? 0) + effect.add\n    } else {\n      value = typeof effect.value === 'string' ? interpolate(effect.value, scope) : effect.value\n    }\n\n    if (state[effect.set] !== value) {\n      changes.push({ key: effect.set, from: state[effect.set], to: value, ai: ai || undefined })\n      state[effect.set] = value\n    }\n  }\n  return changes\n}\n\n// Runs a scenario against a graph for one input and returns the whole trace up front.\n// Pure and deterministic: playing it back (pause, step, rewind) is just moving a cursor.\nexport function runScenario(graph: GraphModel, scenario: Scenario, input: Values): Trace {\n  const titles = new Map(graph.nodes.map((n) => [n.id, n.title]))\n  const nodeTitle = (id: string) => titles.get(id) ?? id\n  const state: Values = { ...scenario.initialState }\n  const steps: TraceStep[] = []\n  let outcome: Outcome = 'stopped'\n  let message = ''\n\n  const scope = (): Scope => ({ input, state })\n  const push = (step: Omit<TraceStep, 'index' | 'state' | 'nodeTitle'>) =>\n    steps.push({ ...step, index: steps.length, nodeTitle: nodeTitle(step.nodeId), state: { ...state } })\n\n  const end = (stepId: string, nodeId: string, result: EndSpec | { outcome: 'stopped'; message: string }) => {\n    outcome = result.outcome\n    message = interpolate(result.message, scope())\n    push({ kind: 'end', stepId, nodeId, title: message, outcome, changes: [], warnings: [] })\n  }\n\n  let current: string | undefined = scenario.start\n  let incoming: { edgeId?: string; from?: string } = {}\n\n  while (current !== undefined) {\n    const rule: StepRule | undefined = scenario.steps[current]\n    if (!rule) {\n      outcome = 'stopped'\n      message = `Step “${current}” is not defined.`\n      break\n    }\n    if (steps.length >= MAX_STEPS) {\n      end(current, rule.node, { outcome: 'stopped', message: `Stopped after ${MAX_STEPS} steps; the scenario may be looping.` })\n      break\n    }\n\n    const changes = applyEffects(rule.effects ?? [], input, state)\n    const warnings: string[] = []\n    if (incoming.from && !incoming.edgeId) {\n      warnings.push(`The diagram has no edge from “${nodeTitle(incoming.from)}” to “${nodeTitle(rule.node)}”.`)\n    }\n    push({\n      kind: 'enter',\n      stepId: current,\n      nodeId: rule.node,\n      edgeId: incoming.edgeId,\n      fromNodeId: incoming.from,\n      title: interpolate(rule.title, scope()),\n      detail: rule.detail ? interpolate(rule.detail, scope()) : undefined,\n      changes,\n      warnings,\n    })\n    const enterIndex = steps.length - 1\n\n    for (const call of rule.calls ?? []) {\n      if (call.when && !evaluate(call.when, scope())) continue\n      const edge = edgeBetween(graph, rule.node, call.to)\n      push({\n        kind: 'call',\n        stepId: current,\n        nodeId: call.to,\n        edgeId: edge?.id,\n        fromNodeId: rule.node,\n        title: interpolate(call.title, scope()),\n        detail: call.detail ? interpolate(call.detail, scope()) : undefined,\n        changes: [],\n        warnings: edge ? [] : [`The diagram has no edge from “${nodeTitle(rule.node)}” to “${nodeTitle(call.to)}”.`],\n      })\n    }\n\n    if (rule.end) {\n      end(current, rule.node, rule.end)\n      break\n    }\n\n    const next: Transition[] = rule.next ?? []\n    if (next.length === 0) {\n      end(current, rule.node, { outcome: 'success', message: 'The flow finished.' })\n      break\n    }\n\n    const taken = next.findIndex((t) => !t.when || evaluate(t.when, scope()))\n    if (next.length > 1) {\n      steps[enterIndex].decision = {\n        options: next.map((t, i) => ({\n          label: t.label ?? (t.when ? describeCondition(t.when) : 'otherwise'),\n          taken: i === taken,\n        })),\n      }\n    }\n    if (taken < 0) {\n      end(current, rule.node, { outcome: 'stopped', message: 'No branch matched here, so the run stopped.' })\n      break\n    }\n\n    const transition: Transition = next[taken]\n    if (transition.end) {\n      end(current, rule.node, transition.end)\n      break\n    }\n\n    const target = transition.to !== undefined ? scenario.steps[transition.to] : undefined\n    const edge = target ? edgeBetween(graph, rule.node, target.node) : undefined\n    incoming = { edgeId: edge?.id, from: rule.node }\n    current = transition.to\n  }\n\n  return { scenarioId: scenario.id, scenarioTitle: scenario.title, input, steps, outcome, message }\n}\n\nexport function defaultInput(scenario: Scenario): Values {\n  return Object.fromEntries(scenario.inputs.map((f) => [f.name, f.default]))\n}\n","import { edgeBetween } from './engine'\nimport type { GraphModel, Scenario, ScenarioIssue } from './types'\n\n// Checks a scenario against the diagram it will run on. Errors mean part of it cannot\n// run; warnings mean it runs but the diagram does not show that hop.\nexport function validateScenario(scenario: Scenario, graph: GraphModel): ScenarioIssue[] {\n  const issues: ScenarioIssue[] = []\n  const nodeIds = new Set(graph.nodes.map((n) => n.id))\n\n  for (const [stepId, step] of Object.entries(scenario.steps)) {\n    if (!nodeIds.has(step.node)) {\n      issues.push({ severity: 'error', message: `Step “${stepId}” refers to a node that is not in the diagram: ${step.node}` })\n    }\n    for (const call of step.calls ?? []) {\n      if (nodeIds.has(step.node) && nodeIds.has(call.to) && !edgeBetween(graph, step.node, call.to)) {\n        issues.push({ severity: 'warning', message: `No edge from ${step.node} to ${call.to} for the call in “${stepId}”.` })\n      }\n    }\n    for (const next of step.next ?? []) {\n      const target = next.to !== undefined ? scenario.steps[next.to] : undefined\n      if (target && nodeIds.has(step.node) && nodeIds.has(target.node) && !edgeBetween(graph, step.node, target.node)) {\n        issues.push({ severity: 'warning', message: `No edge from ${step.node} to ${target.node} for the branch in “${stepId}”.` })\n      }\n    }\n  }\n  return issues\n}\n","import { defaultInput, runScenario } from './engine'\nimport { validateScenario } from './validate'\nimport type { GraphModel, Scenario, ScenarioIssue } from './types'\n\nexport type NewScenarioCheck =\n  | { ok: true; issues: ScenarioIssue[]; preview: { outcome: 'success' | 'failure' | 'blocked' | 'stopped'; message: string; steps: number } }\n  | { ok: false; error: 'duplicate-id' | 'unknown-nodes' | 'invalid'; message: string; issues?: ScenarioIssue[] }\n\nconst MAX_LISTED_NODES = 40\n\n// Everything that has to hold before a scenario written by the assistant is saved into a design. The shape (zod)\n// has already been checked; this is what the shape cannot say: that it fits this diagram, that its inputs make\n// sense, and that it runs. Errors refuse it, with a message the assistant can act on. Warnings come back with it.\nexport function checkNewScenario(scenario: Scenario, graph: GraphModel, existingIds: string[]): NewScenarioCheck {\n  if (existingIds.includes(scenario.id)) {\n    return {\n      ok: false,\n      error: 'duplicate-id',\n      message: `This design already has a scenario with the id \"${scenario.id}\". Use a different id. Existing ids: ${existingIds.join(', ')}.`,\n    }\n  }\n\n  const inputProblems = checkInputs(scenario)\n  if (inputProblems.length > 0) {\n    return { ok: false, error: 'invalid', message: `The scenario's inputs are not usable: ${inputProblems.join(' ')}` }\n  }\n\n  const unknown = unknownNodes(scenario, graph)\n  if (unknown.length > 0) {\n    const byTitle = new Map(graph.nodes.map((n) => [n.title.trim().toLowerCase(), n.id]))\n    const lines = unknown.map((ref) => {\n      const guess = byTitle.get(ref.trim().toLowerCase())\n      return guess ? `\"${ref}\" is a title, not an id; use \"${guess}\".` : `\"${ref}\" is not a node in the diagram.`\n    })\n    const known = graph.nodes.slice(0, MAX_LISTED_NODES).map((n) => `${n.id} (${n.title})`).join(', ')\n    const more = graph.nodes.length > MAX_LISTED_NODES ? `, and ${graph.nodes.length - MAX_LISTED_NODES} more (call getDiagram)` : ''\n    return {\n      ok: false,\n      error: 'unknown-nodes',\n      message: `Steps must happen at nodes that exist. ${lines.join(' ')} Nodes in the diagram: ${known || 'none'}${more}.`,\n    }\n  }\n\n  const trace = runScenario(graph, scenario, defaultInput(scenario))\n  if (trace.outcome === 'stopped') {\n    return { ok: false, error: 'invalid', message: `A trial run with the default inputs did not finish: ${trace.message} Make sure every step either ends or has a branch that always applies (a last one with no \"when\").` }\n  }\n\n  const issues = [...validateScenario(scenario, graph).filter((i) => i.severity === 'warning'), ...lint(scenario)]\n  return { ok: true, issues, preview: { outcome: trace.outcome, message: trace.message, steps: trace.steps.length } }\n}\n\nfunction checkInputs(scenario: Scenario): string[] {\n  const problems: string[] = []\n  const seen = new Set<string>()\n  for (const field of scenario.inputs) {\n    if (seen.has(field.name)) problems.push(`Two inputs are called \"${field.name}\".`)\n    seen.add(field.name)\n    const kind = typeof field.default\n    if (field.type === 'number' && kind !== 'number') problems.push(`Input \"${field.name}\" is a number, so its default must be a number.`)\n    if (field.type === 'boolean' && kind !== 'boolean') problems.push(`Input \"${field.name}\" is a boolean, so its default must be true or false.`)\n    if (field.type === 'text' && kind !== 'string') problems.push(`Input \"${field.name}\" is text, so its default must be a string.`)\n    if (field.type === 'select') {\n      if (!field.options || field.options.length === 0) problems.push(`Input \"${field.name}\" is a select, so it needs \"options\".`)\n      else if (!field.options.includes(String(field.default))) problems.push(`The default of \"${field.name}\" must be one of its options.`)\n    }\n  }\n  return problems\n}\n\n// Node references that are not in the diagram, in first-seen order.\nfunction unknownNodes(scenario: Scenario, graph: GraphModel): string[] {\n  const ids = new Set(graph.nodes.map((n) => n.id))\n  const unknown: string[] = []\n  const check = (ref: string) => {\n    if (!ids.has(ref) && !unknown.includes(ref)) unknown.push(ref)\n  }\n  for (const step of Object.values(scenario.steps)) {\n    check(step.node)\n    for (const call of step.calls ?? []) check(call.to)\n  }\n  return unknown\n}\n\n// Things that still run but are probably mistakes.\nfunction lint(scenario: Scenario): ScenarioIssue[] {\n  const issues: ScenarioIssue[] = []\n  const warn = (message: string) => issues.push({ severity: 'warning', message })\n\n  const inputNames = new Set(scenario.inputs.map((f) => f.name))\n  const stateNames = new Set(Object.keys(scenario.initialState ?? {}))\n  for (const step of Object.values(scenario.steps)) for (const effect of step.effects ?? []) stateNames.add(effect.set)\n\n  const checkRef = (ref: string, where: string) => {\n    const [root, ...rest] = ref.split('.')\n    const name = rest.join('.')\n    if (root === 'input' && !inputNames.has(name)) warn(`${where} reads input.${name}, but the scenario has no input called \"${name}\".`)\n    if (root === 'state' && !stateNames.has(name)) warn(`${where} reads state.${name}, but no step sets it and it is not in initialState.`)\n  }\n\n  const conditionPaths = (condition: unknown): string[] => {\n    if (typeof condition !== 'object' || condition === null) return []\n    const c = condition as Record<string, unknown>\n    if (Array.isArray(c.all)) return c.all.flatMap(conditionPaths)\n    if (Array.isArray(c.any)) return c.any.flatMap(conditionPaths)\n    if ('not' in c) return conditionPaths(c.not)\n    return typeof c.path === 'string' ? [c.path] : []\n  }\n\n  for (const [stepId, step] of Object.entries(scenario.steps)) {\n    const where = `Step “${stepId}”`\n    for (const next of step.next ?? []) for (const path of conditionPaths(next.when)) checkRef(path, where)\n    for (const call of step.calls ?? []) for (const path of conditionPaths(call.when)) checkRef(path, where)\n    for (const effect of step.effects ?? []) if ('derive' in effect) checkRef(effect.derive.from, where)\n  }\n  for (const text of strings(scenario)) {\n    for (const match of text.matchAll(/\\{\\{\\s*([\\w.]+)\\s*\\}\\}/g)) checkRef(match[1], 'The text')\n  }\n\n  for (const preset of scenario.presets ?? []) {\n    for (const key of Object.keys(preset.values)) {\n      if (!inputNames.has(key)) warn(`Preset “${preset.name}” sets \"${key}\", which is not an input.`)\n    }\n  }\n\n  const reached = new Set<string>()\n  const visit = (id: string) => {\n    if (reached.has(id) || !scenario.steps[id]) return\n    reached.add(id)\n    for (const next of scenario.steps[id].next ?? []) if (next.to !== undefined) visit(next.to)\n  }\n  visit(scenario.start)\n  for (const id of Object.keys(scenario.steps)) if (!reached.has(id)) warn(`Step “${id}” can never be reached from the start.`)\n\n  return dedupe(issues)\n}\n\nfunction strings(value: unknown): string[] {\n  if (typeof value === 'string') return [value]\n  if (Array.isArray(value)) return value.flatMap(strings)\n  if (typeof value === 'object' && value !== null) return Object.values(value).flatMap(strings)\n  return []\n}\n\nfunction dedupe(issues: ScenarioIssue[]): ScenarioIssue[] {\n  const seen = new Set<string>()\n  return issues.filter((i) => (seen.has(i.message) ? false : (seen.add(i.message), true)))\n}\n","import type { EdgeHighlight, Highlights, NodeHighlight } from '@glyphlab/diagram-core'\nimport type { Trace } from './types'\n\n// The shape of what is lit up belongs to the diagram (@glyphlab/diagram-core), so the canvas and this agree on it.\nexport type { EdgeHighlight, Highlights, NodeHighlight }\n\nconst OUTCOME_HIGHLIGHT = { success: 'success', failure: 'failure', blocked: 'blocked' } as const\n\n// What the host should light up on its diagram for the steps played so far. Pure data,\n// so the diagram never needs to import the simulator.\nexport function highlightsAt(trace: Trace, cursor: number): Highlights {\n  const nodes: Highlights['nodes'] = {}\n  const edges: Highlights['edges'] = {}\n\n  for (let i = 0; i <= cursor && i < trace.steps.length; i++) {\n    const step = trace.steps[i]\n    nodes[step.nodeId] = 'visited'\n    if (step.edgeId) edges[step.edgeId] = 'visited'\n  }\n\n  const current = trace.steps[cursor]\n  if (current) {\n    const outcome = current.kind === 'end' ? current.outcome : undefined\n    nodes[current.nodeId] = outcome && outcome !== 'stopped' ? OUTCOME_HIGHLIGHT[outcome] : 'active'\n    if (current.edgeId) edges[current.edgeId] = 'active'\n  }\n  return { nodes, edges }\n}\n","import { z } from 'zod'\n\n// The shape of a scenario: a scripted walk through a design's diagram. It is the one definition used by the scenario\n// file format (src/simulation/schema.ts) and by the createScenario tool, so what the assistant is told to write and\n// what the app accepts cannot drift apart. The descriptions are what the model reads.\n\nconst idSchema = z.string().min(1)\nconst primitive = z.union([z.string(), z.number(), z.boolean()])\nconst pathSchema = z\n  .string()\n  .regex(/^(input|state)\\.[\\w]+$/, 'Use input.<name> or state.<name>')\n  .describe('Where to read a value: \"input.<name>\" is something the user entered; \"state.<name>\" is something an earlier step set.')\nconst outcomeSchema = z.enum(['success', 'failure', 'blocked'])\n\nexport type ScenarioCondition =\n  | { all: ScenarioCondition[] }\n  | { any: ScenarioCondition[] }\n  | { not: ScenarioCondition }\n  | { path: string; op: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains' | 'truthy'; value?: string | number | boolean | (string | number | boolean)[] }\n\nexport const conditionSchema: z.ZodType<ScenarioCondition> = z\n  .lazy(() =>\n    z.union([\n      z.strictObject({ all: z.array(conditionSchema) }),\n      z.strictObject({ any: z.array(conditionSchema) }),\n      z.strictObject({ not: conditionSchema }),\n      z.strictObject({\n        path: pathSchema,\n        op: z\n          .enum(['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'contains', 'truthy'])\n          .describe('\"eq\"/\"ne\" compare for equality; \"gt\"/\"gte\"/\"lt\"/\"lte\" compare numbers; \"in\" needs a list as value; \"contains\" is a case-insensitive text match; \"truthy\" needs no value.'),\n        value: z.union([primitive, z.array(primitive)]).optional(),\n      }),\n    ]),\n  )\n  .describe('A test on the input or the run state. Combine tests with {all:[...]}, {any:[...]} or {not:...}.')\n\nconst endSchema = z\n  .strictObject({\n    outcome: outcomeSchema.describe('How the run ended: \"success\", \"failure\" (something went wrong), or \"blocked\" (it was refused or had to stop).'),\n    message: z.string().min(1).describe('One sentence saying what happened. May use {{input.x}} and {{state.x}}.'),\n  })\n  .describe('Ends the run here.')\n\nconst effectSchema = z\n  .union([\n    z.strictObject({ set: idSchema, value: primitive }),\n    z.strictObject({ set: idSchema, add: z.number() }),\n    z.strictObject({\n      set: idSchema,\n      derive: z.strictObject({\n        from: pathSchema,\n        rules: z.array(z.strictObject({ contains: z.array(z.string().min(1)).min(1), value: primitive })).describe('Tried in order; the first whose words appear in the text wins.'),\n        default: primitive,\n      }),\n      ai: z.boolean().optional().describe('Mark the result as something the assistant would work out, in the display.'),\n    }),\n  ])\n  .describe('Changes the run state when the step happens. {set, value} stores a value (text may use {{input.x}}/{{state.x}}); {set, add} adds to a number; {set, derive} reads free text and picks a value by keyword.')\n\nconst transitionSchema = z\n  .strictObject({\n    to: idSchema.optional().describe('The id of the next step (a key of \"steps\").'),\n    end: endSchema.optional(),\n    when: conditionSchema.optional().describe('Take this branch only if the condition holds. Branches are tried in order, so put a branch with no \"when\" last as the fallback.'),\n    label: z.string().optional().describe('A short label for the branch, shown where the choice was made.'),\n  })\n  .refine((t) => (t.to !== undefined) !== (t.end !== undefined), 'A branch needs exactly one of \"to\" or \"end\"')\n  .describe('A way forward from a step: either \"to\" another step, or \"end\" the run.')\n\nconst stepSchema = z\n  .strictObject({\n    node: idSchema.describe('The id of the diagram node where this step happens. Use ids from getDiagram, never titles.'),\n    title: z.string().min(1).describe('What happens here, as a short sentence. May use {{input.x}} and {{state.x}}.'),\n    detail: z.string().optional(),\n    effects: z.array(effectSchema).optional(),\n    calls: z\n      .array(\n        z.strictObject({\n          to: idSchema.describe('The id of a diagram node that this node calls and gets an answer from straight away (a lookup, a tool). Ideally an edge goes from this node to it.'),\n          title: z.string().min(1),\n          detail: z.string().optional(),\n          when: conditionSchema.optional(),\n        }),\n      )\n      .optional()\n      .describe('Side trips to other nodes that return immediately; they show on the diagram but do not move the flow.'),\n    next: z.array(transitionSchema).optional().describe('Where to go after this step. With none (and no \"end\"), the run ends as a success.'),\n    end: endSchema.optional().describe('Ends the run at this step, instead of \"next\".'),\n  })\n  .describe('One step of the scenario, at one diagram node.')\n\nconst inputSchema = z.strictObject({\n  name: z.string().regex(/^\\w+$/).describe('The name used in \"input.<name>\" and {{input.<name>}}. Letters, digits and underscore.'),\n  label: z.string().min(1).describe('What the person sees next to the field.'),\n  type: z.enum(['text', 'number', 'boolean', 'select']),\n  default: primitive.describe('The value used when the person does not change it. Must suit the type.'),\n  options: z.array(z.string()).optional().describe('The choices, for type \"select\".'),\n  help: z.string().optional(),\n  fromChat: z.boolean().optional().describe('Fill this field from what the person wrote in the chat when the scenario is proposed.'),\n})\n\nexport const scenarioSchema = z\n  .strictObject({\n    id: idSchema.describe('A short unique id, lowercase with dashes, for example \"refund-declined\". Not already used by another scenario in the design.'),\n    title: z.string().min(1).describe('The name shown in the scenario list.'),\n    description: z.string().describe('One or two sentences on what the scenario shows.'),\n    triggers: z.array(z.string().min(1)).optional().describe('Words that make the chat suggest this scenario.'),\n    inputs: z.array(inputSchema).describe('What the person can vary before a run. May be empty.'),\n    presets: z.array(z.strictObject({ name: z.string().min(1), values: z.record(z.string(), primitive) })).optional().describe('Named sets of input values, for quick choices.'),\n    initialState: z.record(z.string(), primitive).optional().describe('Starting values of the run state, read as \"state.<name>\".'),\n    start: idSchema.describe('The id of the first step: a key of \"steps\".'),\n    steps: z.record(z.string(), stepSchema).describe('The steps, by id. Branches and \"start\" refer to these ids.'),\n  })\n  .superRefine((scenario, ctx) => {\n    const ids = new Set(Object.keys(scenario.steps))\n    if (!ids.has(scenario.start)) {\n      ctx.addIssue({ code: 'custom', path: ['start'], message: `Start step \"${scenario.start}\" is not defined` })\n    }\n    for (const [stepId, step] of Object.entries(scenario.steps)) {\n      step.next?.forEach((t, i) => {\n        if (t.to !== undefined && !ids.has(t.to)) {\n          ctx.addIssue({ code: 'custom', path: ['steps', stepId, 'next', i, 'to'], message: `Unknown step \"${t.to}\"` })\n        }\n      })\n    }\n  })\n  .describe('A scripted walk through the design: steps at diagram nodes, joined by branches, ending with an outcome.')\n\nexport type ScenarioDraft = z.infer<typeof scenarioSchema>\n","import { z } from 'zod'\nimport { defineFormat, readVersioned, readVersionedOrThrow } from '@glyphlab/diagram-core/versioning'\nimport { scenarioSchema } from './scenarioSchema'\nimport type { ScenarioFile } from './types'\n\nexport const SCENARIO_SCHEMA_VERSION = 1\n\n// The scenario shape itself is shared with the createScenario tool, so the assistant writes what the app reads.\nexport { scenarioSchema } from './scenarioSchema'\n\n// Version 1 of the scenario file format. Frozen once released.\nexport const scenarioFileV1Schema: z.ZodType<ScenarioFile> = z.strictObject({\n  schemaVersion: z.literal(SCENARIO_SCHEMA_VERSION),\n  scenarios: z.array(scenarioSchema),\n})\n\nexport const scenarioFileSchema = scenarioFileV1Schema\n\n// Every version the app can read, oldest first, ending with the current one.\nexport const scenarioFileFormat = defineFormat<ScenarioFile>({\n  name: 'scenario file',\n  history: [{ version: SCENARIO_SCHEMA_VERSION, schema: scenarioFileV1Schema }],\n})\n\n// Throws a typed error; use for trusted input such as bundled samples.\nexport function parseScenarioFile(input: unknown): ScenarioFile {\n  return readVersionedOrThrow(scenarioFileFormat, input)\n}\n\n// Returns a result instead of throwing; use for user-supplied files.\nexport function readScenarioFile(input: unknown) {\n  return readVersioned(scenarioFileFormat, input)\n}\n","import type { Scenario } from './types'\n\n// Bump when the engine's behaviour changes in a way that can change a trace (new condition\n// semantics, a different way of choosing the next step). A recorded result carries the version\n// it was made with, so a replay under a newer engine can say why the result may differ.\nexport const ENGINE_VERSION = 1\n\nfunction stable(value: unknown): string {\n  if (Array.isArray(value)) return `[${value.map(stable).join(',')}]`\n  if (typeof value === 'object' && value !== null) {\n    const entries = Object.entries(value as Record<string, unknown>)\n      .filter(([, v]) => v !== undefined)\n      .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stable(v)}`).join(',')}}`\n  }\n  return JSON.stringify(value)\n}\n\n// A short fingerprint of a scenario's content (FNV-1a over its canonical JSON). It tells a\n// recorded result whether the scenario it ran has been edited since; it is not a security hash.\nexport function scenarioVersion(scenario: Scenario): string {\n  const text = stable(scenario)\n  let hash = 0x811c9dc5\n  for (let i = 0; i < text.length; i++) {\n    hash ^= text.charCodeAt(i)\n    hash = Math.imul(hash, 0x01000193)\n  }\n  return (hash >>> 0).toString(16).padStart(8, '0')\n}\n","import { readDiagram, serializeDiagram } from '@glyphlab/diagram-core'\nimport type { DiagramFile } from '@glyphlab/diagram-core'\nimport { scenarioSchema } from './scenarioSchema'\nimport type { Scenario } from './types'\n\n// One file with a design's diagram and its scenarios, to take out of the app (for a website that shows the diagram and plays\n// the scenarios). The diagram inside is the diagram file itself, and each scenario is the scenario shape, so each is read\n// by the same code that reads them anywhere else.\nexport const DESIGN_EXPORT_FORMAT = 'glyph-design'\nexport const DESIGN_EXPORT_VERSION = 1\n\nexport interface DesignExport {\n  format: typeof DESIGN_EXPORT_FORMAT\n  schemaVersion: typeof DESIGN_EXPORT_VERSION\n  diagram: DiagramFile\n  scenarios: Scenario[]\n}\n\nexport function writeDesignExport(diagram: DiagramFile, scenarios: Scenario[]): string {\n  const file = { format: DESIGN_EXPORT_FORMAT, schemaVersion: DESIGN_EXPORT_VERSION, diagram: JSON.parse(serializeDiagram(diagram)) as unknown, scenarios }\n  return `${JSON.stringify(file, null, 2)}\\n`\n}\n\nexport type ReadDesignExport = { ok: true; diagram: DiagramFile; scenarios: Scenario[]; warnings: string[] } | { ok: false; reason: string }\n\n// Never throws. A scenario that no longer parses is left out with a warning, so one bad scenario does not lose the diagram.\nexport function readDesignExport(text: string): ReadDesignExport {\n  let data: unknown\n  try {\n    data = JSON.parse(text)\n  } catch {\n    return { ok: false, reason: 'The file is not valid JSON.' }\n  }\n  if (typeof data !== 'object' || data === null) return { ok: false, reason: 'This is not a Glyph design file.' }\n  const file = data as Record<string, unknown>\n  if (file.format !== DESIGN_EXPORT_FORMAT) return { ok: false, reason: 'This is not a Glyph design file.' }\n  if (file.schemaVersion !== DESIGN_EXPORT_VERSION) return { ok: false, reason: `schemaVersion ${String(file.schemaVersion)} is not supported (use ${DESIGN_EXPORT_VERSION}).` }\n\n  const diagram = readDiagram(file.diagram)\n  if (!diagram.ok) return { ok: false, reason: 'The diagram in this file could not be read.' }\n\n  const warnings = [...diagram.warnings]\n  const list = Array.isArray(file.scenarios) ? file.scenarios : []\n  const scenarios = list.flatMap((item) => {\n    const parsed = scenarioSchema.safeParse(item)\n    return parsed.success ? [parsed.data as Scenario] : []\n  })\n  if (scenarios.length < list.length) warnings.push('Some scenarios in this file could not be read and were left out.')\n  return { ok: true, diagram: diagram.value, scenarios, warnings }\n}\n"],"mappings":"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","names":["edge","z","z"]}

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@glyphlab/scenario-core",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "The scenario engine: the scenario file format, running a scripted walk against a graph of nodes and edges, checking that it fits, and the highlights a run lights up. No UI.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "*.js",
+    "*.js.map",
+    "*.d.ts",
+    "*.css",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "peerDependencies": {
+    "@glyphlab/diagram-core": "^0.1.1",
+    "zod": "^4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/subtubes-io/subtubes-editor.git",
+    "directory": "packages/scenario-core"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "diagram",
+    "react",
+    "system-design",
+    "glyph"
+  ]
+}