@ripplo/testing 0.0.7 → 0.0.8

package/dist/{chunk-GTHRSFXF.js → chunk-AQ52MYXE.js}

@@ -83,7 +83,7 @@ function compileSteps(steps, accessedKeys, requiresKeys) {
     variables[key] = { default: `test-${key}`, type: "string" };
   });
   const variableNamespaces = { ...requiresKeys };
-  return { entryNode: "step-0", nodes, variableNamespaces, variables, version: 2 };
+  return { entryNode: "step-0", nodes, variableNamespaces, variables };
 }
 function compileNode(step, id, next) {
   const { label, node: raw } = readStep(step);
@@ -116,7 +116,7 @@ function compileGraph(preconditionDefs, testDefs) {
       workflow: def.id
     });
   });
-  return { edges, preconditions, states, version: 3 };
+  return { edges, preconditions, states };
 }
 function resolveDependencyChain(requires, preconditionDefs) {
   const defsByName = new Map(preconditionDefs.map((d) => [d.name, d]));

package/dist/compiler.js

@@ -1,6 +1,6 @@
 import {
   compile
-} from "./chunk-GTHRSFXF.js";
+} from "./chunk-AQ52MYXE.js";
 import "./chunk-MGATMMCZ.js";
 export {
   compile

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   compile
-} from "./chunk-GTHRSFXF.js";
+} from "./chunk-AQ52MYXE.js";
 import "./chunk-MGATMMCZ.js";
 import {
   buildSetCookieHeader,

package/dist/lockfile.d.ts

@@ -1,12 +1,11 @@
+import { Codec } from '@ripplo/spec';
 import { z } from 'zod';
 import { CompileResult } from './compiler.js';
-import '@ripplo/spec';
 import './builder-DTWMrbuv.js';
 import './step-DLfkKI3V.js';
 
-declare const LOCKFILE_VERSION = 1;
 declare const LOCKFILE_RELATIVE_PATH = ".ripplo/ripplo.lock";
-declare const lockfileSchema: z.ZodObject<{
+declare const lockfileBodySchema: z.ZodObject<{
     graph: z.ZodObject<{
         edges: z.ZodArray<z.ZodObject<{
             from: z.ZodString;
@@ -23,11 +22,8 @@ declare const lockfileSchema: z.ZodObject<{
             preconditions: z.ZodArray<z.ZodString>;
             route: z.ZodString;
         }, z.core.$strip>>;
-        version: z.ZodLiteral<3>;
     }, z.core.$strip>;
-    lockfileVersion: z.ZodNumber;
     tests: z.ZodArray<z.ZodObject<{
-        additionalChecks: z.ZodArray<z.ZodString>;
         description: z.ZodString;
         expectedOutcome: z.ZodString;
         implemented: z.ZodBoolean;
@@ -696,12 +692,11 @@ declare const lockfileSchema: z.ZodObject<{
                 key: z.ZodString;
                 type: z.ZodLiteral<"env">;
             }, z.core.$strip>], "type">>>;
-            version: z.ZodLiteral<2>;
         }, z.core.$strip>;
-        warnings: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-type Lockfile = z.infer<typeof lockfileSchema>;
+type Lockfile = z.infer<typeof lockfileBodySchema>;
+declare const lockfileCodec: Codec<Lockfile>;
 declare function compileResultToLockfile(result: CompileResult): Lockfile;
 declare function serializeLockfile(lockfile: Lockfile): string;
 interface ReadLockfileParams {
@@ -720,4 +715,4 @@ interface CompareLockfileParams {
 }
 declare function compareCompileToLockfile({ compiled, existing, }: CompareLockfileParams): LockfileComparison;
 
-export { type CompareLockfileParams, LOCKFILE_RELATIVE_PATH, LOCKFILE_VERSION, type Lockfile, type LockfileComparison, type ReadLockfileParams, type WriteLockfileParams, compareCompileToLockfile, compileResultToLockfile, lockfileSchema, readLockfile, serializeLockfile, writeLockfile };
+export { type CompareLockfileParams, LOCKFILE_RELATIVE_PATH, type Lockfile, type LockfileComparison, type ReadLockfileParams, type WriteLockfileParams, compareCompileToLockfile, compileResultToLockfile, lockfileCodec, readLockfile, serializeLockfile, writeLockfile };

package/dist/lockfile.js

@@ -2,39 +2,163 @@
 import fs from "fs/promises";
 import path from "path";
 
-// ../spec/src/edge.ts
+// ../spec/src/codec.ts
 import { z } from "zod";
-var edgeSchema = z.object({
-  from: z.string().min(1).describe("Key of the source state in the states record"),
-  requiresKeys: z.record(z.string(), z.string()).optional().describe(
+var envelopeSchema = z.object({
+  __codec: z.string().min(1),
+  data: z.unknown(),
+  version: z.number().int().positive()
+});
+var CodecVersionError = class extends Error {
+  codec;
+  currentVersion;
+  gotVersion;
+  constructor(params) {
+    super(
+      `Unsupported ${params.codec} version ${String(params.gotVersion)} (current ${String(params.currentVersion)}). Upgrade Ripplo or rebuild with a compatible CLI.`
+    );
+    this.name = "CodecVersionError";
+    this.codec = params.codec;
+    this.currentVersion = params.currentVersion;
+    this.gotVersion = params.gotVersion;
+  }
+};
+var CodecMismatchError = class extends Error {
+  constructor(params) {
+    super(`Codec mismatch: expected "${params.expected}", got "${params.got}"`);
+    this.name = "CodecMismatchError";
+  }
+};
+function defineCodec(name) {
+  return makeInitial({ legacy: void 0, migrators: [], name, schemas: [] });
+}
+function decodeJson(codec, raw) {
+  const parsed = JSON.parse(raw);
+  return codec.decode(parsed);
+}
+function makeInitial(state) {
+  return {
+    initial: (schema) => makeBuilder(schema, { ...state, schemas: [schema] }),
+    legacy: (adapter) => makeInitial({ ...state, legacy: adapter })
+  };
+}
+function makeBuilder(latestSchema, state) {
+  return {
+    build: () => buildCodec(latestSchema, state),
+    legacy: (adapter) => makeBuilder(latestSchema, { ...state, legacy: adapter }),
+    upgrade: (schema, up) => {
+      const erased = up;
+      return makeBuilder(schema, {
+        ...state,
+        migrators: [...state.migrators, erased],
+        schemas: [...state.schemas, schema]
+      });
+    }
+  };
+}
+function buildCodec(latestSchema, state) {
+  const currentVersion = state.schemas.length;
+  return {
+    currentVersion,
+    name: state.name,
+    decode: (raw) => decodeWith(latestSchema, state, raw),
+    encode: (value) => ({
+      __codec: state.name,
+      data: value,
+      version: currentVersion
+    })
+  };
+}
+function decodeWith(latestSchema, state, raw) {
+  const { data, version } = unwrapEnvelope(state, raw);
+  const migrated = migrateStep(state, data, version);
+  return latestSchema.parse(migrated);
+}
+function unwrapEnvelope(state, raw) {
+  const envelopeResult = envelopeSchema.safeParse(raw);
+  if (envelopeResult.success) {
+    if (envelopeResult.data.__codec !== state.name) {
+      throw new CodecMismatchError({
+        expected: state.name,
+        got: envelopeResult.data.__codec
+      });
+    }
+    return {
+      data: envelopeResult.data.data,
+      version: envelopeResult.data.version
+    };
+  }
+  if (state.legacy != null && state.legacy.detect(raw)) {
+    return { data: raw, version: state.legacy.assumedVersion };
+  }
+  throw new Error(
+    `Cannot decode "${state.name}": value is not a codec envelope and no legacy detector matched.`
+  );
+}
+function migrateStep(state, data, version) {
+  const currentVersion = state.schemas.length;
+  if (version > currentVersion) {
+    throw new CodecVersionError({
+      codec: state.name,
+      currentVersion,
+      gotVersion: version
+    });
+  }
+  if (version === currentVersion) {
+    return data;
+  }
+  const sourceSchema = state.schemas[version - 1];
+  if (sourceSchema == null) {
+    throw new Error(
+      `Codec "${state.name}" missing schema for v${String(version)}; cannot migrate.`
+    );
+  }
+  const validated = sourceSchema.parse(data);
+  const migrator = state.migrators[version - 1];
+  if (migrator == null) {
+    throw new Error(
+      `Codec "${state.name}" missing migrator v${String(version)} \u2192 v${String(version + 1)}.`
+    );
+  }
+  return migrateStep(state, migrator(validated), version + 1);
+}
+
+// ../spec/src/codecs.ts
+import { z as z11 } from "zod";
+
+// ../spec/src/graph.ts
+import { z as z5 } from "zod";
+
+// ../spec/src/edge.ts
+import { z as z2 } from "zod";
+var edgeSchema = z2.object({
+  from: z2.string().min(1).describe("Key of the source state in the states record"),
+  requiresKeys: z2.record(z2.string(), z2.string()).optional().describe(
     "Maps workflow variable namespace to precondition name. Used by the runtime to namespace batch precondition data into dot-namespaced variables (e.g. { project: 'data:project' } maps projectId \u2192 project.projectId)."
   ),
-  to: z.string().min(1).describe("Key of the target state in the states record"),
-  workflow: z.string().min(1).describe(
+  to: z2.string().min(1).describe("Key of the target state in the states record"),
+  workflow: z2.string().min(1).describe(
     "Filename (without .json) of the workflow in .ripplo/workflows/ that executes this edge"
   )
 }).describe("A directed edge between two states, executed by a workflow");
 
-// ../spec/src/graph.ts
-import { z as z4 } from "zod";
-
 // ../spec/src/precondition.ts
-import { z as z2 } from "zod";
-var preconditionSchema = z2.object({
-  depends: z2.array(z2.string().min(1)).optional().describe(
+import { z as z3 } from "zod";
+var preconditionSchema = z3.object({
+  depends: z3.array(z3.string().min(1)).optional().describe(
     "Names of other preconditions that must be satisfied first. Resolved via topological sort; cycles are rejected at validation time."
   ),
-  description: z2.string().min(1).describe("Human-readable description of what this precondition ensures"),
-  returns: z2.array(z2.string().min(1)).optional().describe(
+  description: z3.string().min(1).describe("Human-readable description of what this precondition ensures"),
+  returns: z3.array(z3.string().min(1)).optional().describe(
     "Keys that the execute response's data field will contain. e.g. ['projectId', 'workflowId']. These are used for route param interpolation ({{projectId}}) and workflow variables. Declared here so generated types are strongly typed per precondition."
   )
 }).describe("A named precondition declared at the graph level. States reference these by name.");
 
 // ../spec/src/state.ts
-import { z as z3 } from "zod";
-var stateNodeSchema = z3.object({
-  preconditions: z3.array(z3.string().min(1)).describe("Ordered list of precondition names to satisfy before entering this state"),
-  route: z3.string().min(1).describe(
+import { z as z4 } from "zod";
+var stateNodeSchema = z4.object({
+  preconditions: z4.array(z4.string().min(1)).describe("Ordered list of precondition names to satisfy before entering this state"),
+  route: z4.string().min(1).describe(
     "URL pattern with {{placeholders}} for dynamic segments, e.g. '/projects/{{projectId}}/settings'"
   )
 }).describe(
@@ -42,36 +166,42 @@ var stateNodeSchema = z3.object({
 );
 
 // ../spec/src/graph.ts
-var stateGraphSchema = z4.object({
-  edges: z4.array(edgeSchema).describe("Directed edges between states, each executed by a workflow"),
-  preconditions: z4.record(z4.string(), preconditionSchema).describe(
+var MAX_STATES = 1e3;
+var MAX_EDGES = 5e3;
+var MAX_PRECONDITIONS = 500;
+var stateGraphSchema = z5.object({
+  edges: z5.array(edgeSchema).max(MAX_EDGES).describe("Directed edges between states, each executed by a workflow"),
+  preconditions: z5.record(z5.string().max(200), preconditionSchema).refine(
+    (obj) => Object.keys(obj).length <= MAX_PRECONDITIONS,
+    `Graph has more than ${String(MAX_PRECONDITIONS)} preconditions`
+  ).describe(
     "Named preconditions keyed by name (e.g. 'auth:admin', 'data:three-projects'). States reference these by name."
   ),
-  states: z4.record(z4.string(), stateNodeSchema).describe("States keyed by stable ID (kebab-case)"),
-  version: z4.literal(3).describe("Schema version, always 3")
-}).describe(
-  "Ripplo State Graph v3 \u2014 models application states, edges, and executable preconditions"
-);
+  states: z5.record(z5.string().max(200), stateNodeSchema).refine(
+    (obj) => Object.keys(obj).length <= MAX_STATES,
+    `Graph has more than ${String(MAX_STATES)} states`
+  ).describe("States keyed by stable ID (kebab-case)")
+}).describe("Ripplo State Graph \u2014 models application states, edges, and executable preconditions");
 
 // ../spec/src/schema.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // ../spec/src/locators.ts
-import { z as z5 } from "zod";
-var testIdLocator = z5.object({
-  by: z5.literal("testId"),
-  value: z5.string().min(1)
+import { z as z6 } from "zod";
+var testIdLocator = z6.object({
+  by: z6.literal("testId"),
+  value: z6.string().min(1)
 });
-var roleLocator = z5.object({
-  by: z5.literal("role"),
-  name: z5.string().optional(),
-  role: z5.string().min(1)
+var roleLocator = z6.object({
+  by: z6.literal("role"),
+  name: z6.string().optional(),
+  role: z6.string().min(1)
 });
-var locatorSchema = z5.discriminatedUnion("by", [testIdLocator, roleLocator]);
+var locatorSchema = z6.discriminatedUnion("by", [testIdLocator, roleLocator]);
 
 // ../spec/src/operators.ts
-import { z as z6 } from "zod";
-var comparisonOperator = z6.enum([
+import { z as z7 } from "zod";
+var comparisonOperator = z7.enum([
   "equals",
   "notEquals",
   "contains",
@@ -79,7 +209,7 @@ var comparisonOperator = z6.enum([
   "endsWith",
   "matches"
 ]);
-var numericOperator = z6.enum([
+var numericOperator = z7.enum([
   "equals",
   "notEquals",
   "greaterThan",
@@ -89,240 +219,241 @@ var numericOperator = z6.enum([
 ]);
 
 // ../spec/src/value-ref.ts
-import { z as z7 } from "zod";
-var staticValueSchema = z7.object({
-  type: z7.literal("static"),
-  value: z7.union([z7.string(), z7.number(), z7.boolean()])
+import { z as z8 } from "zod";
+var staticValueSchema = z8.object({
+  type: z8.literal("static"),
+  value: z8.union([z8.string(), z8.number(), z8.boolean()])
 });
-var variableRefSchema = z7.object({
-  name: z7.string().min(1),
-  type: z7.literal("variable")
+var variableRefSchema = z8.object({
+  name: z8.string().min(1),
+  type: z8.literal("variable")
 });
-var valueRefSchema = z7.discriminatedUnion("type", [staticValueSchema, variableRefSchema]);
-var stringValueRefSchema = z7.discriminatedUnion("type", [
-  z7.object({ type: z7.literal("static"), value: z7.string() }),
+var valueRefSchema = z8.discriminatedUnion("type", [staticValueSchema, variableRefSchema]);
+var stringValueRefSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("static"), value: z8.string() }),
   variableRefSchema
 ]);
-var numericValueRefSchema = z7.discriminatedUnion("type", [
-  z7.object({ type: z7.literal("static"), value: z7.number().int().nonnegative() }),
+var numericValueRefSchema = z8.discriminatedUnion("type", [
+  z8.object({ type: z8.literal("static"), value: z8.number().int().nonnegative() }),
   variableRefSchema
 ]);
 
 // ../spec/src/variables.ts
-import { z as z8 } from "zod";
-var variableDefSchema = z8.discriminatedUnion("type", [
-  z8.object({
-    default: z8.string().optional(),
-    type: z8.literal("string")
+import { z as z9 } from "zod";
+var variableDefSchema = z9.discriminatedUnion("type", [
+  z9.object({
+    default: z9.string().optional(),
+    type: z9.literal("string")
   }),
-  z8.object({
-    default: z8.number().optional(),
-    type: z8.literal("number")
+  z9.object({
+    default: z9.number().optional(),
+    type: z9.literal("number")
   }),
-  z8.object({
-    default: z8.boolean().optional(),
-    type: z8.literal("boolean")
+  z9.object({
+    default: z9.boolean().optional(),
+    type: z9.literal("boolean")
   }),
-  z8.object({
-    key: z8.string().min(1),
-    type: z8.literal("env")
+  z9.object({
+    key: z9.string().min(1),
+    type: z9.literal("env")
   })
 ]);
 
 // ../spec/src/schema.ts
 var nodeBase = {
-  comment: z9.string().optional(),
-  id: z9.string().min(1),
-  label: z9.string().optional(),
-  next: z9.string().optional(),
-  timeout: z9.number().int().positive().optional()
+  comment: z10.string().max(2e3).optional(),
+  id: z10.string().min(1).max(200),
+  label: z10.string().max(500).optional(),
+  next: z10.string().max(200).optional(),
+  timeout: z10.number().int().positive().optional()
 };
-var gotoNode = z9.object({
+var MAX_NODES_PER_WORKFLOW = 500;
+var gotoNode = z10.object({
   ...nodeBase,
-  type: z9.literal("goto"),
+  type: z10.literal("goto"),
   url: stringValueRefSchema
 });
-var clickNode = z9.object({ ...nodeBase, locator: locatorSchema, type: z9.literal("click") });
-var fillNode = z9.object({
+var clickNode = z10.object({ ...nodeBase, locator: locatorSchema, type: z10.literal("click") });
+var fillNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("fill"),
+  type: z10.literal("fill"),
   value: stringValueRefSchema
 });
-var selectNode = z9.object({
+var selectNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("select"),
+  type: z10.literal("select"),
   value: stringValueRefSchema
 });
-var hoverNode = z9.object({ ...nodeBase, locator: locatorSchema, type: z9.literal("hover") });
-var pressNode = z9.object({
+var hoverNode = z10.object({ ...nodeBase, locator: locatorSchema, type: z10.literal("hover") });
+var pressNode = z10.object({
   ...nodeBase,
-  key: z9.string().min(1),
+  key: z10.string().min(1),
   locator: locatorSchema.optional(),
-  type: z9.literal("press")
+  type: z10.literal("press")
 });
-var checkNode = z9.object({ ...nodeBase, locator: locatorSchema, type: z9.literal("check") });
-var uncheckNode = z9.object({ ...nodeBase, locator: locatorSchema, type: z9.literal("uncheck") });
-var setViewportNode = z9.object({
+var checkNode = z10.object({ ...nodeBase, locator: locatorSchema, type: z10.literal("check") });
+var uncheckNode = z10.object({ ...nodeBase, locator: locatorSchema, type: z10.literal("uncheck") });
+var setViewportNode = z10.object({
   ...nodeBase,
-  height: z9.number().int().positive(),
-  type: z9.literal("setViewport"),
-  width: z9.number().int().positive()
+  height: z10.number().int().positive(),
+  type: z10.literal("setViewport"),
+  width: z10.number().int().positive()
 });
-var failNode = z9.object({ ...nodeBase, message: z9.string().min(1), type: z9.literal("fail") });
-var setVariableNode = z9.object({
+var failNode = z10.object({ ...nodeBase, message: z10.string().min(1), type: z10.literal("fail") });
+var setVariableNode = z10.object({
   ...nodeBase,
-  type: z9.literal("setVariable"),
+  type: z10.literal("setVariable"),
   value: valueRefSchema,
-  variable: z9.string().min(1)
+  variable: z10.string().min(1)
 });
-var extractTextNode = z9.object({
+var extractTextNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("extractText"),
-  variable: z9.string().min(1)
+  type: z10.literal("extractText"),
+  variable: z10.string().min(1)
 });
-var uploadNode = z9.object({
+var uploadNode = z10.object({
   ...nodeBase,
-  files: z9.array(z9.string()).min(1),
+  files: z10.array(z10.string()).min(1),
   locator: locatorSchema,
-  type: z9.literal("upload")
+  type: z10.literal("upload")
 });
-var dblclickNode = z9.object({
+var dblclickNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("dblclick")
+  type: z10.literal("dblclick")
 });
-var dragNode = z9.object({
+var dragNode = z10.object({
   ...nodeBase,
   source: locatorSchema,
   target: locatorSchema,
-  type: z9.literal("drag")
+  type: z10.literal("drag")
 });
-var scrollIntoViewNode = z9.object({
+var scrollIntoViewNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("scrollIntoView")
+  type: z10.literal("scrollIntoView")
 });
-var typeNode = z9.object({
+var typeNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("type"),
+  type: z10.literal("type"),
   value: stringValueRefSchema
 });
-var focusNode = z9.object({
+var focusNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("focus")
+  type: z10.literal("focus")
 });
-var clearNode = z9.object({ ...nodeBase, locator: locatorSchema, type: z9.literal("clear") });
-var rightClickNode = z9.object({
+var clearNode = z10.object({ ...nodeBase, locator: locatorSchema, type: z10.literal("clear") });
+var rightClickNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("rightClick")
+  type: z10.literal("rightClick")
 });
-var handleDialogNode = z9.object({
+var handleDialogNode = z10.object({
   ...nodeBase,
-  action: z9.enum(["accept", "dismiss"]),
-  promptText: z9.string().optional(),
-  type: z9.literal("handleDialog")
+  action: z10.enum(["accept", "dismiss"]),
+  promptText: z10.string().optional(),
+  type: z10.literal("handleDialog")
 });
-var clipboardNode = z9.object({
+var clipboardNode = z10.object({
   ...nodeBase,
-  action: z9.enum(["read", "write"]),
-  type: z9.literal("clipboard"),
+  action: z10.enum(["read", "write"]),
+  type: z10.literal("clipboard"),
   value: stringValueRefSchema.optional(),
-  variable: z9.string().min(1).optional()
+  variable: z10.string().min(1).optional()
 });
-var setPermissionNode = z9.object({
+var setPermissionNode = z10.object({
   ...nodeBase,
-  permission: z9.string().min(1),
-  state: z9.enum(["granted", "prompt"]),
-  type: z9.literal("setPermission")
+  permission: z10.string().min(1),
+  state: z10.enum(["granted", "prompt"]),
+  type: z10.literal("setPermission")
 });
-var assertVisibleNode = z9.object({
+var assertVisibleNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertVisible")
+  type: z10.literal("assertVisible")
 });
-var assertNotVisibleNode = z9.object({
+var assertNotVisibleNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertNotVisible")
+  type: z10.literal("assertNotVisible")
 });
-var assertTextNode = z9.object({
+var assertTextNode = z10.object({
   ...nodeBase,
   expected: stringValueRefSchema,
   locator: locatorSchema,
   operator: comparisonOperator,
-  type: z9.literal("assertText")
+  type: z10.literal("assertText")
 });
-var assertUrlNode = z9.object({
+var assertUrlNode = z10.object({
   ...nodeBase,
   expected: stringValueRefSchema,
   operator: comparisonOperator,
-  type: z9.literal("assertUrl")
+  type: z10.literal("assertUrl")
 });
-var assertCountNode = z9.object({
+var assertCountNode = z10.object({
   ...nodeBase,
   expected: numericValueRefSchema,
   locator: locatorSchema,
   operator: numericOperator,
-  type: z9.literal("assertCount")
+  type: z10.literal("assertCount")
 });
-var assertValueNode = z9.object({
+var assertValueNode = z10.object({
   ...nodeBase,
   expected: stringValueRefSchema,
   locator: locatorSchema,
   operator: comparisonOperator,
-  type: z9.literal("assertValue")
+  type: z10.literal("assertValue")
 });
-var assertAttributeNode = z9.object({
+var assertAttributeNode = z10.object({
   ...nodeBase,
-  attribute: z9.string().min(1),
+  attribute: z10.string().min(1),
   expected: stringValueRefSchema,
   locator: locatorSchema,
   operator: comparisonOperator,
-  type: z9.literal("assertAttribute")
+  type: z10.literal("assertAttribute")
 });
-var assertEnabledNode = z9.object({
+var assertEnabledNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertEnabled")
+  type: z10.literal("assertEnabled")
 });
-var assertDisabledNode = z9.object({
+var assertDisabledNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertDisabled")
+  type: z10.literal("assertDisabled")
 });
-var assertTitleNode = z9.object({
+var assertTitleNode = z10.object({
   ...nodeBase,
   expected: stringValueRefSchema,
   operator: comparisonOperator,
-  type: z9.literal("assertTitle")
+  type: z10.literal("assertTitle")
 });
-var assertCheckedNode = z9.object({
+var assertCheckedNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertChecked")
+  type: z10.literal("assertChecked")
 });
-var assertNotCheckedNode = z9.object({
+var assertNotCheckedNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertNotChecked")
+  type: z10.literal("assertNotChecked")
 });
-var assertFocusedNode = z9.object({
+var assertFocusedNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertFocused")
+  type: z10.literal("assertFocused")
 });
-var assertNotFocusedNode = z9.object({
+var assertNotFocusedNode = z10.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertNotFocused")
+  type: z10.literal("assertNotFocused")
 });
-var specNodeSchema = z9.discriminatedUnion("type", [
+var specNodeSchema = z10.discriminatedUnion("type", [
   gotoNode,
   clickNode,
   fillNode,
@@ -361,51 +492,67 @@ var specNodeSchema = z9.discriminatedUnion("type", [
   assertFocusedNode,
   assertNotFocusedNode
 ]);
-var workflowSpecSchema = z9.object({
-  entryNode: z9.string().min(1),
-  nodes: z9.record(z9.string(), specNodeSchema),
-  variableNamespaces: z9.record(z9.string(), z9.string()).optional(),
-  variables: z9.record(z9.string(), variableDefSchema).optional(),
-  version: z9.literal(2)
+var workflowSpecSchema = z10.object({
+  entryNode: z10.string().min(1).max(200),
+  nodes: z10.record(z10.string().max(200), specNodeSchema).refine(
+    (nodes) => Object.keys(nodes).length <= MAX_NODES_PER_WORKFLOW,
+    `Workflow has more than ${String(MAX_NODES_PER_WORKFLOW)} nodes`
+  ),
+  variableNamespaces: z10.record(z10.string().max(200), z10.string().max(500)).optional(),
+  variables: z10.record(z10.string().max(200), variableDefSchema).optional()
 });
 
+// ../spec/src/codecs.ts
+var preconditionMapSchema = z11.record(z11.string().max(200), preconditionSchema);
+var looksLikeWorkflowSpec = {
+  assumedVersion: 1,
+  detect: (raw) => typeof raw === "object" && raw !== null && "entryNode" in raw && "nodes" in raw
+};
+var looksLikeStateGraph = {
+  assumedVersion: 1,
+  detect: (raw) => typeof raw === "object" && raw !== null && "edges" in raw && "states" in raw && "preconditions" in raw
+};
+var looksLikePreconditionMap = {
+  assumedVersion: 1,
+  detect: (raw) => typeof raw === "object" && raw !== null && !Array.isArray(raw) && !("__codec" in raw)
+};
+var workflowSpecCodec = defineCodec("workflow-spec").legacy(looksLikeWorkflowSpec).initial(workflowSpecSchema).build();
+var stateGraphCodec = defineCodec("state-graph").legacy(looksLikeStateGraph).initial(stateGraphSchema).build();
+var preconditionMapCodec = defineCodec("precondition-map").legacy(looksLikePreconditionMap).initial(preconditionMapSchema).build();
+
 // src/lockfile.ts
-import { z as z10 } from "zod";
-var LOCKFILE_VERSION = 1;
+import { z as z12 } from "zod";
 var LOCKFILE_RELATIVE_PATH = ".ripplo/ripplo.lock";
-var compiledTestSchema = z10.object({
-  additionalChecks: z10.array(z10.string()),
-  description: z10.string(),
-  expectedOutcome: z10.string(),
-  implemented: z10.boolean(),
-  name: z10.string(),
-  slug: z10.string(),
-  spec: workflowSpecSchema,
-  warnings: z10.array(z10.string())
-});
-var lockfileSchema = z10.object({
+var MAX_TESTS = 5e3;
+var compiledTestSchema = z12.object({
+  description: z12.string().max(2e3),
+  expectedOutcome: z12.string().max(2e3),
+  implemented: z12.boolean(),
+  name: z12.string().max(200),
+  slug: z12.string().max(200),
+  spec: workflowSpecSchema
+});
+var lockfileBodySchema = z12.object({
   graph: stateGraphSchema,
-  lockfileVersion: z10.number().int().positive(),
-  tests: z10.array(compiledTestSchema)
+  tests: z12.array(compiledTestSchema).max(MAX_TESTS)
 });
+var lockfileCodec = defineCodec("ripplo-lockfile").initial(lockfileBodySchema).build();
 function compileResultToLockfile(result) {
   return {
     graph: result.graph,
-    lockfileVersion: LOCKFILE_VERSION,
     tests: result.tests.map((test) => ({
-      additionalChecks: [...test.additionalChecks],
       description: test.description,
       expectedOutcome: test.expectedOutcome,
       implemented: test.implemented,
       name: test.name,
       slug: test.slug,
-      spec: test.spec,
-      warnings: [...test.warnings]
+      spec: test.spec
     }))
   };
 }
 function serializeLockfile(lockfile) {
-  return `${JSON.stringify(lockfile, sortedReplacer(lockfile), 2)}
+  const envelope = lockfileCodec.encode(lockfile);
+  return `${JSON.stringify(envelope, sortedReplacer(envelope), 2)}
 `;
 }
 async function readLockfile({ cwd }) {
@@ -414,8 +561,7 @@ async function readLockfile({ cwd }) {
   if (raw == null) {
     return null;
   }
-  const parsed = JSON.parse(raw);
-  return lockfileSchema.parse(parsed);
+  return decodeJson(lockfileCodec, raw);
 }
 async function writeLockfile({ cwd, result }) {
   const lockfile = compileResultToLockfile(result);
@@ -460,10 +606,9 @@ function isPlainObject(value) {
 }
 export {
   LOCKFILE_RELATIVE_PATH,
-  LOCKFILE_VERSION,
   compareCompileToLockfile,
   compileResultToLockfile,
-  lockfileSchema,
+  lockfileCodec,
   readLockfile,
   serializeLockfile,
   writeLockfile

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ripplo/testing",
   "description": "TypeScript DSL for defining and running Ripplo e2e workflow tests",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "type": "module",
   "files": [
     "dist"
@@ -60,7 +60,7 @@
   },
   "dependencies": {
     "standardwebhooks": "^1.0.0",
-    "zod": "catalog:"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/express": "^5.0.2",