@ripplo/testing 0.6.1 → 0.7.0

package/dist/lockfile.js

@@ -1,707 +0,0 @@
-import "./chunk-4MGIQFAJ.js";
-
-// src/lockfile.ts
-import { createHash } from "crypto";
-import fs from "fs/promises";
-import path from "path";
-
-// ../spec/src/codec.ts
-import { z } from "zod";
-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 z8 } 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(
-    "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(
-    "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/schema.ts
-import { z as z7 } from "zod";
-
-// ../spec/src/locators.ts
-import { z as z3 } from "zod";
-var testIdLocator = z3.object({
-  by: z3.literal("testId"),
-  value: z3.string().min(1)
-});
-var roleLocator = z3.object({
-  by: z3.literal("role"),
-  name: z3.string().optional(),
-  role: z3.string().min(1)
-});
-var locatorSchema = z3.discriminatedUnion("by", [testIdLocator, roleLocator]);
-
-// ../spec/src/operators.ts
-import { z as z4 } from "zod";
-var comparisonOperator = z4.enum([
-  "equals",
-  "notEquals",
-  "contains",
-  "startsWith",
-  "endsWith",
-  "matches"
-]);
-var numericOperator = z4.enum([
-  "equals",
-  "notEquals",
-  "greaterThan",
-  "greaterThanOrEqual",
-  "lessThan",
-  "lessThanOrEqual"
-]);
-
-// ../spec/src/value-ref.ts
-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 = z5.object({
-  name: z5.string().min(1),
-  type: z5.literal("variable")
-});
-var valueRefSchema = z5.discriminatedUnion("type", [staticValueSchema, variableRefSchema]);
-var stringValueRefSchema = z5.discriminatedUnion("type", [
-  z5.object({ type: z5.literal("static"), value: z5.string() }),
-  variableRefSchema
-]);
-var numericValueRefSchema = z5.discriminatedUnion("type", [
-  z5.object({ type: z5.literal("static"), value: z5.number().int().nonnegative() }),
-  variableRefSchema
-]);
-var primitiveValueRefSchema = z5.discriminatedUnion("type", [
-  z5.object({
-    type: z5.literal("static"),
-    value: z5.union([z5.string(), z5.number(), z5.boolean()])
-  }),
-  variableRefSchema
-]);
-
-// ../spec/src/variables.ts
-import { z as z6 } from "zod";
-var variableDefSchema = z6.discriminatedUnion("type", [
-  z6.object({
-    default: z6.string().optional(),
-    type: z6.literal("string")
-  }),
-  z6.object({
-    default: z6.number().optional(),
-    type: z6.literal("number")
-  }),
-  z6.object({
-    default: z6.boolean().optional(),
-    type: z6.literal("boolean")
-  }),
-  z6.object({
-    key: z6.string().min(1),
-    type: z6.literal("env")
-  })
-]);
-
-// ../spec/src/schema.ts
-var nodeBase = {
-  id: z7.string().min(1).max(200),
-  label: z7.string().max(500).optional(),
-  next: z7.string().max(200).optional(),
-  uiOnly: z7.boolean().optional()
-};
-var MAX_NODES_PER_WORKFLOW = 500;
-var gotoNode = z7.object({
-  ...nodeBase,
-  type: z7.literal("goto"),
-  url: stringValueRefSchema
-});
-var clickNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  modifier: z7.enum(["Alt", "Control", "Meta", "Shift"]).optional(),
-  type: z7.literal("click")
-});
-var fillNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("fill"),
-  value: stringValueRefSchema
-});
-var selectNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("select"),
-  value: stringValueRefSchema
-});
-var hoverNode = z7.object({ ...nodeBase, locator: locatorSchema, type: z7.literal("hover") });
-var pressNode = z7.object({
-  ...nodeBase,
-  key: z7.string().min(1),
-  locator: locatorSchema.optional(),
-  type: z7.literal("press")
-});
-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: z7.number().int().positive(),
-  type: z7.literal("setViewport"),
-  width: z7.number().int().positive()
-});
-var failNode = z7.object({ ...nodeBase, message: z7.string().min(1), type: z7.literal("fail") });
-var setVariableNode = z7.object({
-  ...nodeBase,
-  type: z7.literal("setVariable"),
-  value: valueRefSchema,
-  variable: z7.string().min(1)
-});
-var extractTextNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("extractText"),
-  variable: z7.string().min(1)
-});
-var uploadNode = z7.object({
-  ...nodeBase,
-  files: z7.array(z7.string()).min(1),
-  locator: locatorSchema,
-  type: z7.literal("upload")
-});
-var dblclickNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("dblclick")
-});
-var dragNode = z7.object({
-  ...nodeBase,
-  source: locatorSchema,
-  target: locatorSchema,
-  type: z7.literal("drag")
-});
-var scrollIntoViewNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("scrollIntoView")
-});
-var typeNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("type"),
-  value: stringValueRefSchema
-});
-var focusNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("focus")
-});
-var clearNode = z7.object({ ...nodeBase, locator: locatorSchema, type: z7.literal("clear") });
-var rightClickNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("rightClick")
-});
-var handleDialogNode = z7.object({
-  ...nodeBase,
-  action: z7.enum(["accept", "dismiss"]),
-  promptText: z7.string().optional(),
-  type: z7.literal("handleDialog")
-});
-var clipboardNode = z7.object({
-  ...nodeBase,
-  action: z7.enum(["read", "write"]),
-  type: z7.literal("clipboard"),
-  value: stringValueRefSchema.optional(),
-  variable: z7.string().min(1).optional()
-});
-var setPermissionNode = z7.object({
-  ...nodeBase,
-  permission: z7.string().min(1),
-  state: z7.enum(["granted", "prompt"]),
-  type: z7.literal("setPermission")
-});
-var assertVisibleNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("assertVisible")
-});
-var assertNotVisibleNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("assertNotVisible")
-});
-var assertTextNode = z7.object({
-  ...nodeBase,
-  expected: stringValueRefSchema,
-  locator: locatorSchema,
-  operator: comparisonOperator,
-  type: z7.literal("assertText")
-});
-var assertUrlNode = z7.object({
-  ...nodeBase,
-  expected: stringValueRefSchema,
-  operator: comparisonOperator,
-  type: z7.literal("assertUrl")
-});
-var assertCountNode = z7.object({
-  ...nodeBase,
-  expected: numericValueRefSchema,
-  locator: locatorSchema,
-  operator: numericOperator,
-  type: z7.literal("assertCount")
-});
-var assertValueNode = z7.object({
-  ...nodeBase,
-  expected: stringValueRefSchema,
-  locator: locatorSchema,
-  operator: comparisonOperator,
-  type: z7.literal("assertValue")
-});
-var assertAttributeNode = z7.object({
-  ...nodeBase,
-  attribute: z7.string().min(1),
-  expected: stringValueRefSchema,
-  locator: locatorSchema,
-  operator: comparisonOperator,
-  type: z7.literal("assertAttribute")
-});
-var assertEnabledNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("assertEnabled")
-});
-var assertDisabledNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("assertDisabled")
-});
-var assertTitleNode = z7.object({
-  ...nodeBase,
-  expected: stringValueRefSchema,
-  operator: comparisonOperator,
-  type: z7.literal("assertTitle")
-});
-var assertCheckedNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("assertChecked")
-});
-var assertNotCheckedNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("assertNotChecked")
-});
-var assertFocusedNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("assertFocused")
-});
-var assertNotFocusedNode = z7.object({
-  ...nodeBase,
-  locator: locatorSchema,
-  type: z7.literal("assertNotFocused")
-});
-var assertObserverNode = z7.object({
-  ...nodeBase,
-  budget: z7.enum(["fast", "slow", "async"]),
-  observer: z7.string().min(1).max(200),
-  params: z7.record(z7.string().max(200), primitiveValueRefSchema),
-  type: z7.literal("assertObserver")
-});
-var specNodeSchema = z7.discriminatedUnion("type", [
-  gotoNode,
-  clickNode,
-  fillNode,
-  selectNode,
-  hoverNode,
-  pressNode,
-  checkNode,
-  uncheckNode,
-  assertVisibleNode,
-  assertNotVisibleNode,
-  assertTextNode,
-  assertUrlNode,
-  assertCountNode,
-  assertValueNode,
-  assertAttributeNode,
-  assertEnabledNode,
-  assertDisabledNode,
-  setViewportNode,
-  failNode,
-  setVariableNode,
-  extractTextNode,
-  uploadNode,
-  dblclickNode,
-  dragNode,
-  scrollIntoViewNode,
-  typeNode,
-  focusNode,
-  clearNode,
-  rightClickNode,
-  handleDialogNode,
-  clipboardNode,
-  setPermissionNode,
-  assertTitleNode,
-  assertCheckedNode,
-  assertNotCheckedNode,
-  assertFocusedNode,
-  assertNotFocusedNode,
-  assertObserverNode
-]);
-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`
-  ),
-  uiOnly: z7.boolean().optional(),
-  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();
-
-// ../spec/src/observer.ts
-import { z as z9 } from "zod";
-var OBSERVER_BUDGETS = ["fast", "slow", "async"];
-var observerSchema = z9.object({
-  budget: z9.enum(OBSERVER_BUDGETS).describe("Polling budget tier: fast | slow | async"),
-  description: z9.string().min(1).describe("Human-readable description of what this observer checks")
-}).describe(
-  "A named backend state observer. Tests assert against it with assert.backend(observer, params). Implementation lives on the user's server."
-);
-
-// src/lockfile.ts
-import { z as z10 } from "zod";
-var LOCKFILE_RELATIVE_PATH = ".ripplo/ripplo.lock";
-var FIXTURES_RELATIVE_PATH = ".ripplo/fixtures";
-var MAX_TESTS = 5e3;
-var requiresKeysSchema = z10.record(z10.string().max(200), z10.string().max(200));
-var compiledTestSchema = z10.object({
-  coverage: z10.array(z10.string().max(500)).max(2e3).default([]),
-  expectedOutcome: z10.string().max(2e3),
-  name: z10.string().max(200),
-  preconditions: z10.array(z10.string().max(200)).max(1e3),
-  requiresKeys: requiresKeysSchema,
-  slug: z10.string().max(200),
-  sourcePath: z10.string().max(500).optional(),
-  spec: workflowSpecSchema
-});
-var fixtureEntrySchema = z10.object({
-  sha256: z10.string().regex(/^[0-9a-f]{64}$/u),
-  size: z10.number().int().nonnegative()
-});
-var fixturesMapSchema = z10.record(z10.string().min(1).max(500), fixtureEntrySchema);
-var lockfileBodyV1Schema = z10.object({
-  observers: z10.record(z10.string().max(200), observerSchema),
-  preconditions: z10.record(z10.string().max(200), preconditionSchema),
-  tests: z10.array(compiledTestSchema).max(MAX_TESTS)
-});
-var lockfileBodyV2Schema = z10.object({
-  fixtures: fixturesMapSchema,
-  observers: z10.record(z10.string().max(200), observerSchema),
-  preconditions: z10.record(z10.string().max(200), preconditionSchema),
-  tests: z10.array(compiledTestSchema).max(MAX_TESTS)
-});
-var lockfileCodec = defineCodec("ripplo-lockfile").initial(lockfileBodyV1Schema).upgrade(
-  lockfileBodyV2Schema,
-  (prev) => ({
-    ...prev,
-    fixtures: {}
-  })
-).build();
-function compileResultToLockfile(result) {
-  return {
-    fixtures: { ...result.fixtures },
-    observers: result.observers,
-    preconditions: result.preconditions,
-    tests: result.tests.filter((test) => test.implemented).map((test) => ({
-      coverage: [...test.coverage],
-      expectedOutcome: test.expectedOutcome,
-      name: test.name,
-      preconditions: [...test.preconditions],
-      requiresKeys: { ...test.requiresKeys },
-      slug: test.slug,
-      sourcePath: test.sourcePath,
-      spec: test.spec
-    }))
-  };
-}
-function serializeLockfile(lockfile) {
-  const envelope = lockfileCodec.encode(lockfile);
-  return `${JSON.stringify(envelope, sortedReplacer(envelope), 2)}
-`;
-}
-async function readLockfile({ cwd }) {
-  const lockfilePath = path.join(cwd, LOCKFILE_RELATIVE_PATH);
-  const raw = await readFileOrNull(lockfilePath);
-  if (raw == null) {
-    return null;
-  }
-  return decodeJson(lockfileCodec, raw);
-}
-var MAX_FIXTURE_BYTES = 10 * 1024 * 1024;
-var MAX_TOTAL_FIXTURE_BYTES = 50 * 1024 * 1024;
-async function writeLockfile({ cwd, result }) {
-  const hydrated = await hashFixturesIntoCompileResult({ cwd, result });
-  const lockfile = compileResultToLockfile(hydrated);
-  const lockfilePath = path.join(cwd, LOCKFILE_RELATIVE_PATH);
-  await fs.mkdir(path.dirname(lockfilePath), { recursive: true });
-  await fs.writeFile(lockfilePath, serializeLockfile(lockfile), "utf8");
-}
-async function hashFixturesIntoCompileResult({
-  cwd,
-  result
-}) {
-  const referenced = collectFixtureReferences(result);
-  if (referenced.size === 0) {
-    return { ...result, fixtures: {} };
-  }
-  const fixturesRoot = path.join(cwd, FIXTURES_RELATIVE_PATH);
-  const sortedNames = [...referenced].toSorted((a, b) => a.localeCompare(b));
-  const hashed = await Promise.all(
-    sortedNames.map(async (name) => {
-      const entry = await hashOneFixture({ fixturesRoot, name });
-      if (entry.size > MAX_FIXTURE_BYTES) {
-        throw new Error(
-          `Fixture "${name}" is ${String(entry.size)} bytes; exceeds per-file limit of ${String(MAX_FIXTURE_BYTES)} bytes`
-        );
-      }
-      return [name, entry];
-    })
-  );
-  const total = hashed.reduce((sum, [, entry]) => sum + entry.size, 0);
-  if (total > MAX_TOTAL_FIXTURE_BYTES) {
-    throw new Error(
-      `Total fixtures size exceeds limit of ${String(MAX_TOTAL_FIXTURE_BYTES)} bytes`
-    );
-  }
-  return { ...result, fixtures: Object.fromEntries(hashed) };
-}
-async function hashOneFixture({ fixturesRoot, name }) {
-  const rawName = name;
-  if (typeof rawName !== "string" || rawName.length === 0) {
-    throw new Error(
-      `Internal error: upload step produced a non-string fixture name (got ${rawName === null ? "null" : typeof rawName}). This usually means a test passed a non-Fixture value to upload() \u2014 wrap the filename with fixture("file.png").`
-    );
-  }
-  if (name.includes("..") || path.isAbsolute(name)) {
-    throw new Error(`Invalid fixture name "${name}": must be a path under .ripplo/fixtures/`);
-  }
-  const abs = path.join(fixturesRoot, name);
-  const stat = await fs.lstat(abs).catch((error) => {
-    if (isNodeError(error) && error.code === "ENOENT") {
-      throw new Error(`Fixture "${name}" not found at ${abs}`);
-    }
-    throw error;
-  });
-  if (stat.isSymbolicLink()) {
-    throw new Error(`Fixture "${name}" is a symlink; symlinks are not allowed`);
-  }
-  if (!stat.isFile()) {
-    throw new Error(`Fixture "${name}" is not a regular file`);
-  }
-  const bytes = await fs.readFile(abs);
-  const sha256 = createHash("sha256").update(bytes).digest("hex");
-  return { sha256, size: bytes.byteLength };
-}
-function collectFixtureReferences(result) {
-  const names = /* @__PURE__ */ new Set();
-  result.tests.forEach((test) => {
-    Object.entries(test.spec.nodes).forEach(([stepId, node]) => {
-      if (node.type !== "upload") {
-        return;
-      }
-      node.files.forEach((name, i) => {
-        const raw = name;
-        if (typeof raw !== "string" || raw.length === 0) {
-          throw new Error(
-            `Test "${test.slug}" step "${stepId}" upload files[${String(i)}] is not a non-empty string (got ${raw === null ? "null" : typeof raw}). Wrap filenames with fixture(): upload(loc, fixture("file.png")).`
-          );
-        }
-        names.add(raw);
-      });
-    });
-  });
-  return names;
-}
-async function compareCompileToLockfile({
-  compiled,
-  cwd,
-  existing
-}) {
-  if (existing == null) {
-    return "missing";
-  }
-  const hydrated = await hashFixturesIntoCompileResult({ cwd, result: compiled });
-  const fresh = serializeLockfile(compileResultToLockfile(hydrated));
-  const current = serializeLockfile(existing);
-  return fresh === current ? "match" : "stale";
-}
-async function readFileOrNull(filePath) {
-  try {
-    return await fs.readFile(filePath, "utf8");
-  } catch (error) {
-    if (isNodeError(error) && error.code === "ENOENT") {
-      return null;
-    }
-    throw error;
-  }
-}
-function isNodeError(value) {
-  return value instanceof Error && "code" in value;
-}
-function sortedReplacer(root) {
-  return function replacer(_key, value) {
-    if (value === root || !isPlainObject(value)) {
-      return value;
-    }
-    return Object.fromEntries(Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b)));
-  };
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export {
-  FIXTURES_RELATIVE_PATH,
-  LOCKFILE_RELATIVE_PATH,
-  compareCompileToLockfile,
-  compileResultToLockfile,
-  hashFixturesIntoCompileResult,
-  lockfileCodec,
-  readLockfile,
-  serializeLockfile,
-  writeLockfile
-};