@ripplo/testing 0.0.7 → 0.0.9

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

@@ -8,9 +8,16 @@ function compile(ripplo) {
   const preconditionDefs = ripplo.getPreconditions();
   const testDefs = ripplo.getTests();
   validateUniqueIds(testDefs);
-  const tests = testDefs.map((def) => compileTest(def));
-  const graph = compileGraph(preconditionDefs, testDefs);
-  return { config: ripplo.getConfig(), graph, tests };
+  const preconditions = {};
+  preconditionDefs.forEach((def) => {
+    preconditions[def.name] = {
+      depends: [...def.dependsOn],
+      description: def.description,
+      returns: [...def.returns]
+    };
+  });
+  const tests = testDefs.map((def) => compileTest(def, preconditionDefs));
+  return { config: ripplo.getConfig(), preconditions, tests };
 }
 function validateUniqueIds(defs) {
   const seen = /* @__PURE__ */ new Map();
@@ -22,7 +29,7 @@ function validateUniqueIds(defs) {
     seen.set(def.id, def.name);
   });
 }
-function compileTest(def) {
+function compileTest(def, preconditionDefs) {
   const slug = def.id;
   const { accessedKeys, vars } = buildPlaceholderVars(def.requiresKeys);
   const startsAtUrl = def.startsAtFn == null ? void 0 : def.startsAtFn(vars);
@@ -36,12 +43,15 @@ function compileTest(def) {
       "Test requires preconditions but never references their data \u2014 destructure and use precondition data in steps()"
     );
   }
+  const resolvedPreconditions = resolveDependencyChain(def.requires, preconditionDefs);
   return {
     additionalChecks: [],
     description: def.description,
     expectedOutcome: def.expectedOutcome,
     implemented: def.implemented,
     name: def.name,
+    preconditions: resolvedPreconditions,
+    requiresKeys: { ...def.requiresKeys },
     slug,
     spec,
     warnings
@@ -83,41 +93,12 @@ 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);
   return { ...raw, id, label, next };
 }
-function compileGraph(preconditionDefs, testDefs) {
-  const preconditions = {};
-  preconditionDefs.forEach((def) => {
-    preconditions[def.name] = {
-      depends: [...def.dependsOn],
-      description: def.description,
-      returns: [...def.returns]
-    };
-  });
-  const states = {};
-  const edges = [];
-  testDefs.forEach((def) => {
-    if (!def.implemented || def.startsAtFn == null) {
-      return;
-    }
-    const resolved = resolveDependencyChain(def.requires, preconditionDefs);
-    const { vars } = buildPlaceholderVars(def.requiresKeys);
-    const route = def.startsAtFn(vars);
-    const stateId = deriveStateId(resolved, route);
-    states[stateId] = { preconditions: [...resolved], route };
-    edges.push({
-      from: stateId,
-      requiresKeys: def.requiresKeys,
-      to: stateId,
-      workflow: def.id
-    });
-  });
-  return { edges, preconditions, states, version: 3 };
-}
 function resolveDependencyChain(requires, preconditionDefs) {
   const defsByName = new Map(preconditionDefs.map((d) => [d.name, d]));
   const resolved = [];
@@ -137,13 +118,6 @@ function resolveDependencyChain(requires, preconditionDefs) {
   });
   return resolved;
 }
-function deriveStateId(preconditions, route) {
-  const sorted = preconditions.toSorted((a, b) => a.localeCompare(b));
-  return slugify(`${sorted.join("-")}-${route}`);
-}
-function slugify(input) {
-  return input.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-|-$/g, "");
-}
 
 export {
   compile

package/dist/compiler.d.ts

@@ -1,11 +1,11 @@
-import { StateGraph, WorkflowSpec } from '@ripplo/spec';
+import { Precondition, WorkflowSpec } from '@ripplo/spec';
 import { D as DslConfig, R as RipploBuilder } from './builder-DTWMrbuv.js';
 import 'zod';
 import './step-DLfkKI3V.js';
 
 interface CompileResult {
     readonly config: DslConfig;
-    readonly graph: StateGraph;
+    readonly preconditions: Record<string, Precondition>;
     readonly tests: ReadonlyArray<CompiledTest>;
 }
 interface CompiledTest {
@@ -14,6 +14,8 @@ interface CompiledTest {
     readonly expectedOutcome: string;
     readonly implemented: boolean;
     readonly name: string;
+    readonly preconditions: ReadonlyArray<string>;
+    readonly requiresKeys: Record<string, string>;
     readonly slug: string;
     readonly spec: WorkflowSpec;
     readonly warnings: ReadonlyArray<string>;

package/dist/compiler.js

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

package/dist/index.js

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

package/dist/lockfile.d.ts

@@ -1,37 +1,21 @@
+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<{
-    graph: z.ZodObject<{
-        edges: z.ZodArray<z.ZodObject<{
-            from: z.ZodString;
-            requiresKeys: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-            to: z.ZodString;
-            workflow: z.ZodString;
-        }, z.core.$strip>>;
-        preconditions: z.ZodRecord<z.ZodString, z.ZodObject<{
-            depends: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            description: z.ZodString;
-            returns: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-        states: z.ZodRecord<z.ZodString, 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>;
+declare const lockfileBodySchema: z.ZodObject<{
+    preconditions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        depends: z.ZodOptional<z.ZodArray<z.ZodString>>;
         description: z.ZodString;
+        returns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    tests: z.ZodArray<z.ZodObject<{
         expectedOutcome: z.ZodString;
-        implemented: z.ZodBoolean;
         name: z.ZodString;
+        preconditions: z.ZodArray<z.ZodString>;
+        requiresKeys: z.ZodRecord<z.ZodString, z.ZodString>;
         slug: z.ZodString;
         spec: z.ZodObject<{
             entryNode: z.ZodString;
@@ -696,12 +680,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 +703,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,21 +2,129 @@
 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(
-    "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(
-    "Filename (without .json) of the workflow in .ripplo/workflows/ that executes this edge"
-  )
-}).describe("A directed edge between two states, executed by a workflow");
+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/graph.ts
-import { z as z4 } from "zod";
+// ../spec/src/codecs.ts
+import { z as z8 } from "zod";
 
 // ../spec/src/precondition.ts
 import { z as z2 } from "zod";
@@ -30,48 +138,25 @@ var preconditionSchema = z2.object({
   )
 }).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(
-    "URL pattern with {{placeholders}} for dynamic segments, e.g. '/projects/{{projectId}}/settings'"
-  )
-}).describe(
-  "A distinct application state \u2014 a unique combination of location, auth context, and data conditions"
-);
-
-// ../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(
-    "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"
-);
-
 // ../spec/src/schema.ts
-import { z as z9 } from "zod";
+import { z as z7 } 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 z3 } from "zod";
+var testIdLocator = z3.object({
+  by: z3.literal("testId"),
+  value: z3.string().min(1)
 });
-var roleLocator = z5.object({
-  by: z5.literal("role"),
-  name: z5.string().optional(),
-  role: z5.string().min(1)
+var roleLocator = z3.object({
+  by: z3.literal("role"),
+  name: z3.string().optional(),
+  role: z3.string().min(1)
 });
-var locatorSchema = z5.discriminatedUnion("by", [testIdLocator, roleLocator]);
+var locatorSchema = z3.discriminatedUnion("by", [testIdLocator, roleLocator]);
 
 // ../spec/src/operators.ts
-import { z as z6 } from "zod";
-var comparisonOperator = z6.enum([
+import { z as z4 } from "zod";
+var comparisonOperator = z4.enum([
   "equals",
   "notEquals",
   "contains",
@@ -79,7 +164,7 @@ var comparisonOperator = z6.enum([
   "endsWith",
   "matches"
 ]);
-var numericOperator = z6.enum([
+var numericOperator = z4.enum([
   "equals",
   "notEquals",
   "greaterThan",
@@ -89,240 +174,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 z5 } from "zod";
+var staticValueSchema = z5.object({
+  type: z5.literal("static"),
+  value: z5.union([z5.string(), z5.number(), z5.boolean()])
 });
-var variableRefSchema = z7.object({
-  name: z7.string().min(1),
-  type: z7.literal("variable")
+var variableRefSchema = z5.object({
+  name: z5.string().min(1),
+  type: z5.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 = z5.discriminatedUnion("type", [staticValueSchema, variableRefSchema]);
+var stringValueRefSchema = z5.discriminatedUnion("type", [
+  z5.object({ type: z5.literal("static"), value: z5.string() }),
   variableRefSchema
 ]);
-var numericValueRefSchema = z7.discriminatedUnion("type", [
-  z7.object({ type: z7.literal("static"), value: z7.number().int().nonnegative() }),
+var numericValueRefSchema = z5.discriminatedUnion("type", [
+  z5.object({ type: z5.literal("static"), value: z5.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 z6 } from "zod";
+var variableDefSchema = z6.discriminatedUnion("type", [
+  z6.object({
+    default: z6.string().optional(),
+    type: z6.literal("string")
   }),
-  z8.object({
-    default: z8.number().optional(),
-    type: z8.literal("number")
+  z6.object({
+    default: z6.number().optional(),
+    type: z6.literal("number")
   }),
-  z8.object({
-    default: z8.boolean().optional(),
-    type: z8.literal("boolean")
+  z6.object({
+    default: z6.boolean().optional(),
+    type: z6.literal("boolean")
   }),
-  z8.object({
-    key: z8.string().min(1),
-    type: z8.literal("env")
+  z6.object({
+    key: z6.string().min(1),
+    type: z6.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: z7.string().max(2e3).optional(),
+  id: z7.string().min(1).max(200),
+  label: z7.string().max(500).optional(),
+  next: z7.string().max(200).optional(),
+  timeout: z7.number().int().positive().optional()
 };
-var gotoNode = z9.object({
+var MAX_NODES_PER_WORKFLOW = 500;
+var gotoNode = z7.object({
   ...nodeBase,
-  type: z9.literal("goto"),
+  type: z7.literal("goto"),
   url: stringValueRefSchema
 });
-var clickNode = z9.object({ ...nodeBase, locator: locatorSchema, type: z9.literal("click") });
-var fillNode = z9.object({
+var clickNode = z7.object({ ...nodeBase, locator: locatorSchema, type: z7.literal("click") });
+var fillNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("fill"),
+  type: z7.literal("fill"),
   value: stringValueRefSchema
 });
-var selectNode = z9.object({
+var selectNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("select"),
+  type: z7.literal("select"),
   value: stringValueRefSchema
 });
-var hoverNode = z9.object({ ...nodeBase, locator: locatorSchema, type: z9.literal("hover") });
-var pressNode = z9.object({
+var hoverNode = z7.object({ ...nodeBase, locator: locatorSchema, type: z7.literal("hover") });
+var pressNode = z7.object({
   ...nodeBase,
-  key: z9.string().min(1),
+  key: z7.string().min(1),
   locator: locatorSchema.optional(),
-  type: z9.literal("press")
+  type: z7.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 = z7.object({ ...nodeBase, locator: locatorSchema, type: z7.literal("check") });
+var uncheckNode = z7.object({ ...nodeBase, locator: locatorSchema, type: z7.literal("uncheck") });
+var setViewportNode = z7.object({
   ...nodeBase,
-  height: z9.number().int().positive(),
-  type: z9.literal("setViewport"),
-  width: z9.number().int().positive()
+  height: z7.number().int().positive(),
+  type: z7.literal("setViewport"),
+  width: z7.number().int().positive()
 });
-var failNode = z9.object({ ...nodeBase, message: z9.string().min(1), type: z9.literal("fail") });
-var setVariableNode = z9.object({
+var failNode = z7.object({ ...nodeBase, message: z7.string().min(1), type: z7.literal("fail") });
+var setVariableNode = z7.object({
   ...nodeBase,
-  type: z9.literal("setVariable"),
+  type: z7.literal("setVariable"),
   value: valueRefSchema,
-  variable: z9.string().min(1)
+  variable: z7.string().min(1)
 });
-var extractTextNode = z9.object({
+var extractTextNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("extractText"),
-  variable: z9.string().min(1)
+  type: z7.literal("extractText"),
+  variable: z7.string().min(1)
 });
-var uploadNode = z9.object({
+var uploadNode = z7.object({
   ...nodeBase,
-  files: z9.array(z9.string()).min(1),
+  files: z7.array(z7.string()).min(1),
   locator: locatorSchema,
-  type: z9.literal("upload")
+  type: z7.literal("upload")
 });
-var dblclickNode = z9.object({
+var dblclickNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("dblclick")
+  type: z7.literal("dblclick")
 });
-var dragNode = z9.object({
+var dragNode = z7.object({
   ...nodeBase,
   source: locatorSchema,
   target: locatorSchema,
-  type: z9.literal("drag")
+  type: z7.literal("drag")
 });
-var scrollIntoViewNode = z9.object({
+var scrollIntoViewNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("scrollIntoView")
+  type: z7.literal("scrollIntoView")
 });
-var typeNode = z9.object({
+var typeNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("type"),
+  type: z7.literal("type"),
   value: stringValueRefSchema
 });
-var focusNode = z9.object({
+var focusNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("focus")
+  type: z7.literal("focus")
 });
-var clearNode = z9.object({ ...nodeBase, locator: locatorSchema, type: z9.literal("clear") });
-var rightClickNode = z9.object({
+var clearNode = z7.object({ ...nodeBase, locator: locatorSchema, type: z7.literal("clear") });
+var rightClickNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("rightClick")
+  type: z7.literal("rightClick")
 });
-var handleDialogNode = z9.object({
+var handleDialogNode = z7.object({
   ...nodeBase,
-  action: z9.enum(["accept", "dismiss"]),
-  promptText: z9.string().optional(),
-  type: z9.literal("handleDialog")
+  action: z7.enum(["accept", "dismiss"]),
+  promptText: z7.string().optional(),
+  type: z7.literal("handleDialog")
 });
-var clipboardNode = z9.object({
+var clipboardNode = z7.object({
   ...nodeBase,
-  action: z9.enum(["read", "write"]),
-  type: z9.literal("clipboard"),
+  action: z7.enum(["read", "write"]),
+  type: z7.literal("clipboard"),
   value: stringValueRefSchema.optional(),
-  variable: z9.string().min(1).optional()
+  variable: z7.string().min(1).optional()
 });
-var setPermissionNode = z9.object({
+var setPermissionNode = z7.object({
   ...nodeBase,
-  permission: z9.string().min(1),
-  state: z9.enum(["granted", "prompt"]),
-  type: z9.literal("setPermission")
+  permission: z7.string().min(1),
+  state: z7.enum(["granted", "prompt"]),
+  type: z7.literal("setPermission")
 });
-var assertVisibleNode = z9.object({
+var assertVisibleNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertVisible")
+  type: z7.literal("assertVisible")
 });
-var assertNotVisibleNode = z9.object({
+var assertNotVisibleNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertNotVisible")
+  type: z7.literal("assertNotVisible")
 });
-var assertTextNode = z9.object({
+var assertTextNode = z7.object({
   ...nodeBase,
   expected: stringValueRefSchema,
   locator: locatorSchema,
   operator: comparisonOperator,
-  type: z9.literal("assertText")
+  type: z7.literal("assertText")
 });
-var assertUrlNode = z9.object({
+var assertUrlNode = z7.object({
   ...nodeBase,
   expected: stringValueRefSchema,
   operator: comparisonOperator,
-  type: z9.literal("assertUrl")
+  type: z7.literal("assertUrl")
 });
-var assertCountNode = z9.object({
+var assertCountNode = z7.object({
   ...nodeBase,
   expected: numericValueRefSchema,
   locator: locatorSchema,
   operator: numericOperator,
-  type: z9.literal("assertCount")
+  type: z7.literal("assertCount")
 });
-var assertValueNode = z9.object({
+var assertValueNode = z7.object({
   ...nodeBase,
   expected: stringValueRefSchema,
   locator: locatorSchema,
   operator: comparisonOperator,
-  type: z9.literal("assertValue")
+  type: z7.literal("assertValue")
 });
-var assertAttributeNode = z9.object({
+var assertAttributeNode = z7.object({
   ...nodeBase,
-  attribute: z9.string().min(1),
+  attribute: z7.string().min(1),
   expected: stringValueRefSchema,
   locator: locatorSchema,
   operator: comparisonOperator,
-  type: z9.literal("assertAttribute")
+  type: z7.literal("assertAttribute")
 });
-var assertEnabledNode = z9.object({
+var assertEnabledNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertEnabled")
+  type: z7.literal("assertEnabled")
 });
-var assertDisabledNode = z9.object({
+var assertDisabledNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertDisabled")
+  type: z7.literal("assertDisabled")
 });
-var assertTitleNode = z9.object({
+var assertTitleNode = z7.object({
   ...nodeBase,
   expected: stringValueRefSchema,
   operator: comparisonOperator,
-  type: z9.literal("assertTitle")
+  type: z7.literal("assertTitle")
 });
-var assertCheckedNode = z9.object({
+var assertCheckedNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertChecked")
+  type: z7.literal("assertChecked")
 });
-var assertNotCheckedNode = z9.object({
+var assertNotCheckedNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertNotChecked")
+  type: z7.literal("assertNotChecked")
 });
-var assertFocusedNode = z9.object({
+var assertFocusedNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertFocused")
+  type: z7.literal("assertFocused")
 });
-var assertNotFocusedNode = z9.object({
+var assertNotFocusedNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z9.literal("assertNotFocused")
+  type: z7.literal("assertNotFocused")
 });
-var specNodeSchema = z9.discriminatedUnion("type", [
+var specNodeSchema = z7.discriminatedUnion("type", [
   gotoNode,
   clickNode,
   fillNode,
@@ -361,51 +447,63 @@ 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 = z7.object({
+  entryNode: z7.string().min(1).max(200),
+  nodes: z7.record(z7.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: z7.record(z7.string().max(200), z7.string().max(500)).optional(),
+  variables: z7.record(z7.string().max(200), variableDefSchema).optional()
 });
 
+// ../spec/src/codecs.ts
+var preconditionMapSchema = z8.record(z8.string().max(200), preconditionSchema);
+var looksLikeWorkflowSpec = {
+  assumedVersion: 1,
+  detect: (raw) => typeof raw === "object" && raw !== null && "entryNode" in raw && "nodes" 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 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 z9 } 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({
-  graph: stateGraphSchema,
-  lockfileVersion: z10.number().int().positive(),
-  tests: z10.array(compiledTestSchema)
-});
+var MAX_TESTS = 5e3;
+var requiresKeysSchema = z9.record(z9.string().max(200), z9.string().max(200));
+var compiledTestSchema = z9.object({
+  expectedOutcome: z9.string().max(2e3),
+  name: z9.string().max(200),
+  preconditions: z9.array(z9.string().max(200)).max(1e3),
+  requiresKeys: requiresKeysSchema,
+  slug: z9.string().max(200),
+  spec: workflowSpecSchema
+});
+var lockfileBodySchema = z9.object({
+  preconditions: z9.record(z9.string().max(200), preconditionSchema),
+  tests: z9.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,
+    preconditions: result.preconditions,
+    tests: result.tests.filter((test) => test.implemented).map((test) => ({
       expectedOutcome: test.expectedOutcome,
-      implemented: test.implemented,
       name: test.name,
+      preconditions: [...test.preconditions],
+      requiresKeys: { ...test.requiresKeys },
       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 +512,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 +557,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.9",
   "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",