@suss/extractor 0.29.0 → 0.30.0

package/dist/index.js

@@ -166,893 +166,802 @@ import {
   readHttpMetadata,
   readWrapperMetadata as readWrapperMetadata2,
   withinScope,
-  withWrapperMetadata
+  withWrapperMetadata,
+  wrapperFor,
+  wrapperIndex
 } from "@suss/behavioral-ir";
-
-// src/paths/enumeratePaths.ts
-import { CATCH_ENTRY_TEXT } from "@suss/behavioral-ir";
-var MAX_PATHS = 256;
-var UnmodeledFlow = class extends Error {
-};
-var PathBudgetExceeded = class extends Error {
-};
-function branchCond(branchStmt, condition, polarity, oppositeExit) {
-  return {
-    info: {
-      sourceText: condition.sourceText,
-      polarity,
-      source: "explicit",
-      expression: condition.expression
-    },
-    branchStmt,
-    oppositeExit
-  };
+function composeWrappers(summaries, options = {}) {
+  const chain = wrapperIndex(summaries);
+  const keepGaps = options.gapHandling !== "silent";
+  return summaries.map((summary) => composeOne(summary, chain, keepGaps));
 }
-function fixedCond(condition, polarity, source) {
-  return {
-    info: {
-      sourceText: condition.sourceText,
-      polarity,
-      source,
-      expression: condition.expression
-    },
-    branchStmt: null,
-    oppositeExit: null
+function composeOne(summary, chain, keepGaps) {
+  const recorded = readWrapperMetadata2(summary);
+  const applied = recorded?.applied ?? [];
+  const covering = applied.filter(
+    (reference) => coversUnit(reference, summary)
+  );
+  const narrowed = covering.length === applied.length ? summary : {
+    ...summary,
+    metadata: withWrapperMetadata(summary.metadata, {
+      applied: covering
+    })
   };
-}
-var loopIterationCond = (headerText) => fixedCond(
-  { sourceText: `some iteration of: ${headerText}`, expression: null },
-  "positive",
-  "explicit"
-);
-var loopCompletedCond = (headerText, exit) => fixedCond(
-  {
-    sourceText: `loop exited via ${exit ?? "return"}: ${headerText}`,
-    expression: null
-  },
-  "negative",
-  exit === "throw" ? "earlyThrow" : "earlyReturn"
-);
-var catchEntryCond = () => fixedCond(
-  { sourceText: CATCH_ENTRY_TEXT, expression: null },
-  "positive",
-  "catchBlock"
-);
-function classify(path4, home, isAncestorOrSelf) {
-  return path4.map((cond) => {
-    if (cond.branchStmt === null) {
-      return cond.info;
-    }
-    const encloses = home !== null && isAncestorOrSelf(cond.branchStmt, home);
-    if (encloses || cond.info.polarity === "positive" || cond.oppositeExit === null) {
-      return { ...cond.info, source: "explicit" };
-    }
-    const source = cond.oppositeExit === "throw" ? "earlyThrow" : "earlyReturn";
-    return { ...cond.info, source };
+  const wrappers = covering.flatMap((reference) => {
+    const found = wrapperFor(chain, reference);
+    return found === void 0 ? [] : [{ reference, summary: found }];
   });
-}
-function childrenOf(stmt) {
-  return [...ownBlocksOf(stmt), ...(stmt.callbacks ?? []).flat()];
-}
-function ownBlocksOf(stmt) {
-  if (stmt.kind === "if") {
-    return stmt.elseBody === null ? stmt.thenBody : [...stmt.thenBody, ...stmt.elseBody];
+  if (wrappers.length === 0) {
+    return narrowed;
   }
-  if (stmt.kind === "switch") {
-    return stmt.groups.flatMap((g) => g.body);
+  const responses = respondedInstead(wrappers);
+  const handled = handledThrows(wrappers);
+  const transitions = beside(summary, responses, handled);
+  if (!keepGaps) {
+    return transitions === summary.transitions ? narrowed : { ...narrowed, transitions };
   }
-  if (stmt.kind === "loop") {
-    return stmt.body;
+  const gaps = withContractStatusGaps(
+    summary,
+    [...responses, ...summary.transitions],
+    handled
+  );
+  if (transitions === summary.transitions && gaps === summary.gaps) {
+    return narrowed;
   }
-  if (stmt.kind === "try") {
-    return [
-      ...stmt.tryBody,
-      ...stmt.catchBody ?? [],
-      ...stmt.finallyBody ?? []
-    ];
+  return { ...narrowed, transitions, gaps };
+}
+function beside(summary, responses, handled) {
+  const throws = summary.transitions.some((t) => t.output.type === "throw");
+  const onThrow = throws ? handled : [];
+  if (responses.length === 0 && onThrow.length === 0) {
+    return summary.transitions;
   }
-  return [];
+  return withDistinctIds([...responses, ...summary.transitions, ...onThrow]);
 }
-function hasStrayBreak(nodes) {
-  return nodes.some((node) => {
-    if (node.kind === "exit" && node.exit === "break") {
-      return true;
-    }
-    if (node.kind === "switch" || node.kind === "loop") {
-      return false;
-    }
-    return hasStrayBreak(ownBlocksOf(node));
-  });
+function respondedInstead(wrappers) {
+  return wrappers.flatMap(
+    (wrapper) => wrapper.reference.onThrow === true ? [] : attribute(
+      wrapper.summary.transitions.filter(
+        (t) => t.output.type !== "delegate"
+      ),
+      wrapper.reference
+    )
+  );
 }
-function exitKindOfList(stmts) {
-  let sawReturn = false;
-  for (const stmt of stmts) {
-    if (stmt.exitKind === "throw") {
-      return "throw";
-    }
-    if (stmt.exitKind === "return") {
-      sawReturn = true;
-    }
-  }
-  return sawReturn ? "return" : null;
+function handledThrows(wrappers) {
+  return wrappers.flatMap(
+    (wrapper) => wrapper.reference.onThrow === true ? attribute(wrapper.summary.transitions, wrapper.reference) : []
+  );
 }
-function chargeBudget(state) {
-  state.pathCount++;
-  if (state.pathCount > MAX_PATHS) {
-    throw new PathBudgetExceeded(
-      `path budget exceeded, more than ${MAX_PATHS} paths`
-    );
+function withContractStatusGaps(summary, composed, handled) {
+  const contract = readHttpMetadata(summary)?.declaredContract;
+  const binding = summary.identity.boundaryBinding;
+  if (contract === void 0 || binding !== null && !exchangesHttpResponses(binding)) {
+    return summary.gaps;
   }
+  const declared = {
+    framework: contract.framework ?? "declared",
+    responses: contract.responses
+  };
+  const stale = new Set(
+    contractStatusGaps(declared, summary.transitions).map(gapKey)
+  );
+  const gaps = [
+    ...summary.gaps.filter((gap) => !stale.has(gapKey(gap))),
+    ...contractStatusGaps(declared, [...composed, ...handled])
+  ];
+  const unchanged = gaps.length === summary.gaps.length && gaps.every((gap, i) => gapKey(gap) === gapKey(summary.gaps[i]));
+  return unchanged ? summary.gaps : gaps;
 }
-function recordTerminal(ctx, terminal, home, path4) {
-  chargeBudget(ctx.state);
-  const info = classify(path4, home, ctx.isAncestorOrSelf);
-  const existing = ctx.state.byTerminal.get(terminal) ?? [];
-  existing.push(info);
-  ctx.state.byTerminal.set(terminal, existing);
+function gapKey(gap) {
+  return `${gap.type}|${gap.description}`;
 }
-function containsTerminal(ctx, stmt) {
-  if ((ctx.terminalsByStmt.get(stmt)?.length ?? 0) > 0) {
+function coversUnit(reference, summary) {
+  if (reference.scope === void 0) {
     return true;
   }
-  return childrenOf(stmt).some((child) => containsTerminal(ctx, child));
+  const binding = summary.identity.boundaryBinding;
+  return binding !== null && withinScope(binding, reference.scope);
 }
-function stepIf(stmt, path4, ctx) {
-  const thenExit = exitKindOfList(stmt.thenBody);
-  const elseExit = stmt.elseBody === null ? null : exitKindOfList(stmt.elseBody);
-  const thenPath = [
-    ...path4,
-    branchCond(stmt, stmt.condition, "positive", elseExit)
-  ];
-  const elsePath = [
-    ...path4,
-    branchCond(
-      stmt,
-      stmt.condition,
-      "negative",
-      stmt.elseBody === null ? thenExit : null
-    )
-  ];
-  const out = [];
-  out.push(...enumerate(ctx, stmt.thenBody, thenPath));
-  if (stmt.elseBody !== null) {
-    out.push(...enumerate(ctx, stmt.elseBody, elsePath));
-  } else {
-    out.push(elsePath);
+function attribute(transitions, reference) {
+  return transitions.map((transition) => ({
+    ...transition,
+    metadata: withWrapperMetadata(transition.metadata, { from: reference })
+  }));
+}
+function withDistinctIds(transitions) {
+  const seen = /* @__PURE__ */ new Map();
+  return transitions.map((transition) => {
+    const taken = seen.get(transition.id);
+    seen.set(transition.id, (taken ?? 0) + 1);
+    return taken === void 0 ? transition : { ...transition, id: `${transition.id}#${taken + 1}` };
+  });
+}
+
+// src/effectGuards.ts
+var keyOf = (condition) => `${condition.polarity}:${condition.sourceText}`;
+var opposite = (condition) => `${condition.polarity === "positive" ? "negative" : "positive"}:${condition.sourceText}`;
+function guardsHoldOn(preconditions, conditions) {
+  if (preconditions === void 0 || preconditions.length === 0) {
+    return true;
   }
-  return out;
+  const onBranch = new Set(conditions.map(keyOf));
+  return preconditions.every(
+    (precondition) => !onBranch.has(opposite(precondition))
+  );
 }
-function stepSwitch(stmt, path4, ctx) {
-  const out = [];
-  const negations = [];
-  let defaultRanBody = false;
-  for (let i = 0; i < stmt.groups.length; i++) {
-    const group = stmt.groups[i];
-    const fallthroughSafe = i === stmt.groups.length - 1;
-    if (hasStrayBreak(group.body)) {
-      throw new UnmodeledFlow("non-trailing break in switch clause");
-    }
-    const groupPath = group.condition === null ? [...path4, ...negations] : [...path4, fixedCond(group.condition, "positive", "explicit")];
-    const conts = enumerate(ctx, group.body, groupPath);
-    if (conts.length > 0) {
-      if (!group.hasTrailingBreak && !fallthroughSafe) {
-        throw new UnmodeledFlow("fallthrough into a non-empty switch clause");
-      }
-      out.push(...conts);
+function runsBefore(effectLine, terminalEndLine) {
+  return effectLine <= terminalEndLine;
+}
+
+// src/moduleImports.ts
+function stampModuleImports(summaries, importsOf) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const summary of summaries) {
+    const file = summary.location.file;
+    if (!byFile.has(file)) {
+      const found = importsOf(file);
+      byFile.set(
+        file,
+        found === void 0 ? void 0 : [...new Set(found)].sort()
+      );
     }
-    if (group.condition === null) {
-      defaultRanBody = true;
-    } else {
-      const exit = exitKindOfList(group.body);
-      const negationSource = exit === "throw" ? "earlyThrow" : exit === "return" ? "earlyReturn" : "explicit";
-      negations.push(fixedCond(group.condition, "negative", negationSource));
+    const imports = byFile.get(file);
+    if (imports === void 0) {
+      continue;
     }
+    summary.metadata = {
+      ...summary.metadata ?? {},
+      moduleImports: imports
+    };
   }
-  if (!defaultRanBody) {
-    out.push([...path4, ...negations]);
-  }
-  return out;
-}
-function stepLoop(stmt, path4, ctx) {
-  const bodyExit = exitKindOfList(stmt.body);
-  if (containsTerminal(ctx, stmt)) {
-    enumerate(ctx, stmt.body, [
-      ...path4,
-      loopIterationCond(stmt.condition.sourceText)
-    ]);
-  }
-  if (bodyExit !== null) {
-    return [[...path4, loopCompletedCond(stmt.condition.sourceText, bodyExit)]];
-  }
-  return [path4];
 }
-function stepTry(stmt, path4, ctx) {
-  if (stmt.finallyBody !== null) {
-    const finallyHasTerminal = stmt.finallyBody.some(
-      (s) => containsTerminal(ctx, s)
-    );
-    if (exitKindOfList(stmt.finallyBody) !== null || finallyHasTerminal) {
-      throw new UnmodeledFlow("finally block with exits or terminals");
-    }
-  }
-  const out = [];
-  out.push(...enumerate(ctx, stmt.tryBody, path4));
-  if (stmt.catchBody !== null) {
-    const catchPath = [...path4, catchEntryCond()];
-    out.push(...enumerate(ctx, stmt.catchBody, catchPath));
-  }
-  return out;
+
+// src/moduleInit.ts
+function moduleInitStructure(options) {
+  const { name, file, range, effects } = options;
+  return {
+    identity: {
+      name,
+      kind: "module-init",
+      file,
+      range,
+      exportName: null,
+      exportPath: null
+    },
+    boundaryBinding: null,
+    parameters: [],
+    branches: [
+      {
+        conditions: [],
+        terminal: {
+          kind: "void",
+          statusCode: null,
+          body: null,
+          exceptionType: null,
+          message: null,
+          component: null,
+          renderTree: null,
+          delegateTarget: null,
+          emitEvent: null,
+          location: range
+        },
+        effects: [],
+        extraEffects: effects,
+        location: range,
+        isDefault: true
+      }
+    ],
+    unmatchedReturns: 0,
+    dependencyCalls: [],
+    declaredContract: null
+  };
 }
-function stepExit(stmt, path4, ctx) {
-  const collector = ctx.state.callbackExits[ctx.state.callbackExits.length - 1];
-  if (collector !== void 0 && (stmt.exit === "return" || stmt.exit === "throw")) {
-    collector.push(path4);
+
+// src/packHelpers.ts
+function httpRouteDiscovery(opts) {
+  const kind = opts.kind ?? "handler";
+  const calls = opts.importNames.map((importName) => ({
+    kind,
+    match: {
+      type: "registrationCall",
+      importModule: opts.importModule,
+      importName,
+      registrationChain: [...opts.methods]
+    },
+    bindingExtraction: {
+      // `.all` registers every method, so it records "*", which the pairing
+      // engine treats as agreeing with any method at all.
+      method: {
+        type: "fromRegistration",
+        position: "methodName",
+        nameMap: { all: "*" }
+      },
+      path: { type: "fromArgument", position: 0 }
+    },
+    ...opts.mount !== void 0 ? { mount: opts.mount } : {},
+    requiresImport: [opts.importModule]
+  }));
+  if (opts.importNames.length === 0) {
+    return calls;
   }
-  return [];
+  return [
+    ...calls,
+    // Routes registered in a loop over an array of specs, a shape
+    // registration-call discovery cannot see. The receiver comes from
+    // the same import declaration as the calls above, so a loop that
+    // never touches this library's routable is left alone.
+    {
+      kind,
+      match: {
+        type: "registrationLoop",
+        elementShape: LOOP_ELEMENT_SHAPE,
+        receiver: {
+          importModule: opts.importModule,
+          importNames: [...opts.importNames]
+        }
+      },
+      requiresImport: [opts.importModule]
+    }
+  ];
 }
-function stepOpaque(_stmt, path4, _ctx) {
-  return [path4];
+function wrapperDiscovery(opts) {
+  return opts.importNames.flatMap(
+    (importName) => opts.wraps.map((wraps) => ({
+      kind: opts.kind ?? "middleware",
+      match: {
+        type: "registrationCall",
+        importModule: opts.importModule,
+        importName,
+        registrationChain: []
+      },
+      wraps: { ...wraps },
+      requiresImport: [opts.importModule]
+    }))
+  );
 }
-var stepHandlers = {
-  if: stepIf,
-  switch: stepSwitch,
-  loop: stepLoop,
-  try: stepTry,
-  exit: stepExit,
-  opaque: stepOpaque
+var LOOP_ELEMENT_SHAPE = {
+  methodKey: "method",
+  pathKey: "path",
+  handlerKey: "handler"
 };
-function stepCallback(ctx, body, path4) {
-  const exits = [];
-  ctx.state.callbackExits.push(exits);
-  let fellThrough;
-  try {
-    fellThrough = enumerate(ctx, body, path4);
-  } finally {
-    ctx.state.callbackExits.pop();
-  }
-  const out = [...fellThrough, ...exits];
-  return out.length === 0 ? [path4] : out;
-}
-function stepStatement(ctx, stmt, path4) {
-  let paths = [path4];
-  for (const body of stmt.callbacks ?? []) {
-    paths = paths.flatMap((each) => stepCallback(ctx, body, each));
-  }
-  const ownTerminals = ctx.terminalsByStmt.get(stmt) ?? [];
-  for (const each of withRejoined(paths)) {
-    for (const terminal of ownTerminals) {
-      recordTerminal(ctx, terminal, stmt, each);
+function registrationHelperDiscovery(helpers, kind = "handler") {
+  return helpers.map((helper) => ({
+    kind,
+    match: {
+      type: "registrationTemplate",
+      helperName: helper.helperName,
+      ...helper.importModule !== void 0 ? { importModule: helper.importModule } : {},
+      ...helper.subject !== void 0 ? { subject: helper.subject } : {},
+      registrations: helper.registrations.map((one) => ({ ...one }))
     }
-  }
-  const handler = stepHandlers[stmt.kind];
-  return paths.flatMap(
-    (each) => handler(
-      stmt,
-      each,
-      ctx
+  }));
+}
+function routeHelperIndex(opts) {
+  const methods = new Set(
+    opts.methods.map(
+      (method) => method.startsWith(".") ? method.slice(1) : method
     )
   );
+  return {
+    find: { by: "subject" },
+    declare: (helpers) => ({
+      discovery: registrationHelperDiscovery(
+        helpers.flatMap((helper) => routesRegisteredBy(helper, methods, opts)),
+        opts.kind ?? "handler"
+      )
+    })
+  };
 }
-function soleDisagreement(left, right) {
-  if (left.length !== right.length) {
-    return null;
-  }
-  let found = null;
-  for (let at = 0; at < left.length; at++) {
-    const one = left[at];
-    const other = right[at];
-    if (one === other) {
+function routesRegisteredBy(helper, methods, opts) {
+  const registrations = [];
+  let subjectArgument;
+  for (const sink of helper.sinks) {
+    const registration = routeRegisteredBy(helper, sink, methods);
+    if (registration === null) {
       continue;
     }
-    if (found !== null) {
-      return null;
-    }
-    if (one === void 0 || other === void 0 || one.branchStmt === null || one.branchStmt !== other.branchStmt || one.info.polarity === other.info.polarity) {
-      return null;
+    registrations.push(registration);
+    if (sink.receiver.as === "parameter") {
+      subjectArgument = sink.receiver.position;
     }
-    found = at;
   }
-  return found;
+  if (registrations.length === 0 || subjectArgument === void 0) {
+    return [];
+  }
+  return [
+    {
+      helperName: helper.name,
+      importModule: helper.file,
+      subject: {
+        argument: subjectArgument,
+        importModule: opts.importModule,
+        importNames: [...opts.importNames]
+      },
+      registrations
+    }
+  ];
 }
-function mergeRejoined(paths) {
-  let current = paths;
-  for (let round = 0; round < current.length; round++) {
-    const out = [];
-    const taken = /* @__PURE__ */ new Set();
-    let mergedAny = false;
-    for (let i = 0; i < current.length; i++) {
-      if (taken.has(i)) {
-        continue;
-      }
-      let combined = current[i];
-      for (let j = i + 1; j < current.length; j++) {
-        if (taken.has(j)) {
-          continue;
-        }
-        const at = soleDisagreement(combined, current[j]);
-        if (at === null) {
-          continue;
-        }
-        combined = [...combined.slice(0, at), ...combined.slice(at + 1)];
-        taken.add(j);
-        mergedAny = true;
-        break;
-      }
-      out.push(combined);
-    }
-    current = out;
-    if (!mergedAny) {
-      break;
-    }
+function routeRegisteredBy(helper, sink, methods) {
+  if (sink.method === null || !methods.has(sink.method)) {
+    return null;
   }
-  return current;
-}
-function withRejoined(paths) {
-  const merged = mergeRejoined(paths);
-  return merged.length === paths.length ? paths : [...merged, ...paths];
-}
-function enumerate(ctx, stmts, prefix) {
-  let frontiers = [[...prefix]];
-  for (const stmt of stmts) {
-    const nextFrontiers = [];
-    for (const path4 of mergeRejoined(frontiers)) {
-      nextFrontiers.push(...stepStatement(ctx, stmt, path4));
-    }
-    frontiers = nextFrontiers;
-    if (frontiers.length > MAX_PATHS) {
-      throw new PathBudgetExceeded(
-        `path budget exceeded, more than ${MAX_PATHS} paths`
-      );
-    }
-    if (frontiers.length === 0) {
-      break;
-    }
+  const { receiver } = sink;
+  if (receiver.as !== "parameter" || receiver.property !== void 0 || !helper.subjectParameters.includes(receiver.position)) {
+    return null;
   }
-  return frontiers;
-}
-function buildParentMap(statements) {
-  const parentOf = /* @__PURE__ */ new Map();
-  const visit = (stmt, parent) => {
-    parentOf.set(stmt, parent);
-    for (const child of childrenOf(stmt)) {
-      visit(child, stmt);
-    }
-  };
-  for (const stmt of statements) {
-    visit(stmt, null);
+  const pathTemplate = sink.arguments[0];
+  const handler = sink.arguments[sink.arguments.length - 1];
+  if (sink.arguments.length < 2 || pathTemplate === void 0 || pathTemplate.as !== "text" || handler === void 0) {
+    return null;
   }
-  return parentOf;
-}
-function enumerateStructuredPaths(input) {
-  const parentOf = buildParentMap(input.statements);
-  const isAncestorOrSelf = (a, b) => {
-    let current = b;
-    while (current !== null) {
-      if (current === a) {
-        return true;
-      }
-      current = parentOf.get(current) ?? null;
-    }
-    return false;
-  };
-  const state = {
-    byTerminal: /* @__PURE__ */ new Map(),
-    fallthrough: [],
-    pathCount: 0,
-    callbackExits: []
-  };
-  const ctx = {
-    terminalsByStmt: input.terminalsByStmt,
-    state,
-    isAncestorOrSelf
+  const handlerArg = handlerSlot(handler);
+  return handlerArg === null ? null : {
+    // `.all` registers every method, which the pairing engine
+    // spells as a wildcard.
+    method: sink.method === "all" ? "*" : sink.method.toUpperCase(),
+    pathTemplate: pathTemplate.text,
+    handlerArg
   };
-  const continuations = withRejoined(enumerate(ctx, input.statements, []));
-  for (const path4 of continuations) {
-    chargeBudget(state);
-    state.fallthrough.push(classify(path4, null, isAncestorOrSelf));
-  }
-  return { byTerminal: state.byTerminal, fallthrough: state.fallthrough };
 }
-function enumerateOrDegrade(input, terminals) {
-  try {
-    return { ...enumerateStructuredPaths(input), degraded: null };
-  } catch (error) {
-    const reason = reasonToDegrade(error);
-    if (reason === null) {
-      throw error;
-    }
-    const marker = {
-      sourceText: `unmodeled control flow (${reason})`,
-      polarity: "positive",
-      source: "explicit",
-      expression: null
-    };
-    const byTerminal = /* @__PURE__ */ new Map();
-    for (const terminal of terminals) {
-      byTerminal.set(terminal, [[marker]]);
-    }
-    return { byTerminal, fallthrough: [[marker]], degraded: reason };
+function handlerSlot(value) {
+  if (value.as !== "parameter") {
+    return null;
   }
+  return value.property === void 0 ? `{${value.position}}` : `{${value.position}}.${value.property}`;
 }
-function reasonToDegrade(error) {
-  if (error instanceof PathBudgetExceeded) {
-    return error.message === "" ? "path budget exceeded" : error.message;
+function unwrapJsonStringify(body) {
+  if (body === null || typeof body !== "object") {
+    return body;
   }
-  if (error instanceof UnmodeledFlow) {
-    return error.message;
+  const candidate = body;
+  if (candidate.kind !== "call" || candidate.callee !== "JSON.stringify") {
+    return body;
   }
-  return null;
+  const inner = candidate.args?.[0];
+  return inner ?? body;
 }
 
-// src/composeWrappers.ts
-var BUDGET_GAP = {
-  type: "unreadOutcome",
-  conditions: [],
-  consequence: "unknown",
-  description: `Composing the wrappers registered around this unit would have gone past the path budget of ${MAX_PATHS}, so what each of them produces is reported beside this unit's own outcomes rather than under the conditions that reach it`
+// src/packOptions.ts
+import { z } from "zod";
+var storageSystemOption = z.enum([
+  "postgresql",
+  "mysql",
+  "sqlite"
+]);
+var scopeOption = z.string();
+var configuredCallOption = z.object({
+  /** Module that declares the receiver's type. */
+  module: z.string(),
+  /** Type name of the receiver, as exported from that module. */
+  receiver: z.string(),
+  /** Method that performs the send. */
+  method: z.string(),
+  /** Argument index carrying the subject. */
+  subjectArg: z.number(),
+  /**
+   * Which argument the message body is. Left out when the method has no
+   * single body argument, as a batch method taking a list of entries
+   * does, and then no body is reported.
+   */
+  bodyArg: z.number().optional()
+}).strict();
+
+// src/paths/enumeratePaths.ts
+import { CATCH_ENTRY_TEXT } from "@suss/behavioral-ir";
+var MAX_PATHS = 256;
+var UnmodeledFlow = class extends Error {
 };
-function composeWrappers(summaries, options = {}) {
-  const byKey = /* @__PURE__ */ new Map();
-  for (const summary of summaries) {
-    const key = summaryKey(summary.location.file, summary.identity.name);
-    const sharing = byKey.get(key);
-    if (sharing === void 0) {
-      byKey.set(key, [summary]);
-      continue;
-    }
-    sharing.push(summary);
-  }
-  const keepGaps = options.gapHandling !== "silent";
-  return summaries.map((summary) => composeOne(summary, byKey, keepGaps));
-}
-function summaryKey(file, name) {
-  return `${file}::${name}`;
-}
-function summaryOf(reference, byKey) {
-  const sharing = byKey.get(summaryKey(reference.file, reference.name)) ?? [];
-  if (reference.line === void 0) {
-    return sharing[0];
-  }
-  return sharing.find((one) => one.location.range.start === reference.line) ?? sharing[0];
-}
-function composeOne(summary, byKey, keepGaps) {
-  const recorded = readWrapperMetadata2(summary);
-  const applied = recorded?.applied ?? [];
-  const covering = applied.filter(
-    (reference) => coversUnit(reference, summary)
-  );
-  const narrowed = covering.length === applied.length ? summary : {
-    ...summary,
-    metadata: withWrapperMetadata(summary.metadata, {
-      applied: covering
-    })
-  };
-  const wrappers = covering.flatMap((reference) => {
-    const found = summaryOf(reference, byKey);
-    return found === void 0 ? [] : [{ reference, summary: found }];
-  });
-  if (wrappers.length === 0) {
-    return narrowed;
-  }
-  let composition = {
-    transitions: summary.transitions,
-    degraded: false
-  };
-  for (const wrapper of [...wrappers].reverse()) {
-    if (wrapper.reference.onThrow === true) {
-      continue;
-    }
-    composition = merge(composition, applyWrapper(wrapper, composition));
-  }
-  for (const wrapper of wrappers) {
-    if (wrapper.reference.onThrow !== true) {
-      continue;
-    }
-    composition = merge(composition, applyThrowWrapper(wrapper, composition));
-  }
-  const transitions = composition.transitions === summary.transitions ? summary.transitions : withDistinctIds(composition.transitions);
-  if (!keepGaps) {
-    return { ...narrowed, transitions };
-  }
-  const gaps = withContractStatusGaps(summary, transitions, wrappers);
-  if (transitions === summary.transitions && gaps === summary.gaps) {
-    return narrowed;
-  }
+var PathBudgetExceeded = class extends Error {
+};
+function branchCond(branchStmt, condition, polarity, oppositeExit) {
   return {
-    ...narrowed,
-    transitions,
-    gaps: composition.degraded ? [...gaps, BUDGET_GAP] : gaps
-  };
-}
-function withContractStatusGaps(summary, composed, wrappers) {
-  const contract = readHttpMetadata(summary)?.declaredContract;
-  const binding = summary.identity.boundaryBinding;
-  if (contract === void 0 || binding !== null && !exchangesHttpResponses(binding)) {
-    return summary.gaps;
-  }
-  const declared = {
-    framework: contract.framework ?? "declared",
-    responses: contract.responses
+    info: {
+      sourceText: condition.sourceText,
+      polarity,
+      source: "explicit",
+      expression: condition.expression
+    },
+    branchStmt,
+    oppositeExit
   };
-  const stale = new Set(
-    contractStatusGaps(declared, summary.transitions).map(gapKey)
-  );
-  const onThrow = wrappers.filter((wrapper) => wrapper.reference.onThrow === true).flatMap(
-    (wrapper) => attribute(wrapper.summary.transitions, wrapper.reference)
-  );
-  const gaps = [
-    ...summary.gaps.filter((gap) => !stale.has(gapKey(gap))),
-    ...contractStatusGaps(declared, [...composed, ...onThrow])
-  ];
-  const unchanged = gaps.length === summary.gaps.length && gaps.every((gap, i) => gapKey(gap) === gapKey(summary.gaps[i]));
-  return unchanged ? summary.gaps : gaps;
 }
-function gapKey(gap) {
-  return `${gap.type}|${gap.description}`;
-}
-function merge(before, step) {
+function fixedCond(condition, polarity, source) {
   return {
-    transitions: step.transitions,
-    degraded: before.degraded || step.degraded
+    info: {
+      sourceText: condition.sourceText,
+      polarity,
+      source,
+      expression: condition.expression
+    },
+    branchStmt: null,
+    oppositeExit: null
   };
 }
-function coversUnit(reference, summary) {
-  if (reference.scope === void 0) {
-    return true;
-  }
-  const binding = summary.identity.boundaryBinding;
-  return binding !== null && withinScope(binding, reference.scope);
-}
-function applyWrapper(wrapper, inner) {
-  const shortCircuits = attribute(
-    wrapper.summary.transitions.filter((t) => t.output.type !== "delegate"),
-    wrapper.reference
-  );
-  const passThroughs = withoutCoveredPassThroughs(
-    wrapper.summary.transitions.filter((t) => t.output.type === "delegate")
-  );
-  if (passThroughs.length === 0 || shortCircuits.length + passThroughs.length * inner.transitions.length > MAX_PATHS) {
-    return {
-      transitions: [...shortCircuits, ...inner.transitions],
-      degraded: passThroughs.length > 0
-    };
-  }
-  const continued = passThroughs.flatMap(
-    (passThrough) => inner.transitions.map((transition) => splice(passThrough, transition))
-  );
-  return { transitions: [...shortCircuits, ...continued], degraded: false };
+var loopIterationCond = (headerText) => fixedCond(
+  { sourceText: `some iteration of: ${headerText}`, expression: null },
+  "positive",
+  "explicit"
+);
+var loopCompletedCond = (headerText, exit) => fixedCond(
+  {
+    sourceText: `loop exited via ${exit ?? "return"}: ${headerText}`,
+    expression: null
+  },
+  "negative",
+  exit === "throw" ? "earlyThrow" : "earlyReturn"
+);
+var catchEntryCond = () => fixedCond(
+  { sourceText: CATCH_ENTRY_TEXT, expression: null },
+  "positive",
+  "catchBlock"
+);
+function classify(path4, home, isAncestorOrSelf) {
+  return path4.map((cond) => {
+    if (cond.branchStmt === null) {
+      return cond.info;
+    }
+    const encloses = home !== null && isAncestorOrSelf(cond.branchStmt, home);
+    if (encloses || cond.info.polarity === "positive" || cond.oppositeExit === null) {
+      return { ...cond.info, source: "explicit" };
+    }
+    const source = cond.oppositeExit === "throw" ? "earlyThrow" : "earlyReturn";
+    return { ...cond.info, source };
+  });
 }
-function withoutCoveredPassThroughs(passThroughs) {
-  return passThroughs.filter(
-    (candidate, i) => !passThroughs.some(
-      (other, j) => j !== i && covers(other, candidate) && (j < i || !covers(candidate, other))
-    )
-  );
+function childrenOf(stmt) {
+  return [...ownBlocksOf(stmt), ...(stmt.callbacks ?? []).flat()];
 }
-function covers(wider, narrower) {
-  if (JSON.stringify(wider.effects) !== JSON.stringify(narrower.effects)) {
-    return false;
+function ownBlocksOf(stmt) {
+  if (stmt.kind === "if") {
+    return stmt.elseBody === null ? stmt.thenBody : [...stmt.thenBody, ...stmt.elseBody];
   }
-  const required = new Set(narrower.conditions.map((c) => JSON.stringify(c)));
-  return wider.conditions.every((c) => required.has(JSON.stringify(c)));
-}
-function applyThrowWrapper(wrapper, inner) {
-  const thrown = inner.transitions.filter((t) => t.output.type === "throw");
-  if (thrown.length === 0) {
-    return inner;
+  if (stmt.kind === "switch") {
+    return stmt.groups.flatMap((g) => g.body);
   }
-  const rest = inner.transitions.filter((t) => t.output.type !== "throw");
-  const handled = wrapper.summary.transitions;
-  if (rest.length + thrown.length * handled.length > MAX_PATHS) {
-    return {
-      transitions: [
-        ...inner.transitions,
-        ...attribute(handled, wrapper.reference)
-      ],
-      degraded: true
-    };
+  if (stmt.kind === "loop") {
+    return stmt.body;
   }
-  const composed = thrown.flatMap(
-    (transition) => attribute(
-      handled.map((handler) => splice(transition, handler)),
-      wrapper.reference
-    )
-  );
-  return { transitions: [...rest, ...composed], degraded: false };
+  if (stmt.kind === "try") {
+    return [
+      ...stmt.tryBody,
+      ...stmt.catchBody ?? [],
+      ...stmt.finallyBody ?? []
+    ];
+  }
+  return [];
 }
-function splice(outer, inner) {
-  return {
-    ...inner,
-    id: `${inner.id}:via:${outer.id}`,
-    conditions: [...outer.conditions, ...inner.conditions],
-    effects: [...outer.effects, ...inner.effects],
-    isDefault: outer.isDefault && inner.isDefault
-  };
+function hasStrayBreak(nodes) {
+  return nodes.some((node) => {
+    if (node.kind === "exit" && node.exit === "break") {
+      return true;
+    }
+    if (node.kind === "switch" || node.kind === "loop") {
+      return false;
+    }
+    return hasStrayBreak(ownBlocksOf(node));
+  });
 }
-function attribute(transitions, reference) {
-  return transitions.map((transition) => ({
-    ...transition,
-    metadata: withWrapperMetadata(transition.metadata, { from: reference })
-  }));
+function exitKindOfList(stmts) {
+  let sawReturn = false;
+  for (const stmt of stmts) {
+    if (stmt.exitKind === "throw") {
+      return "throw";
+    }
+    if (stmt.exitKind === "return") {
+      sawReturn = true;
+    }
+  }
+  return sawReturn ? "return" : null;
 }
-function withDistinctIds(transitions) {
-  const seen = /* @__PURE__ */ new Map();
-  return transitions.map((transition) => {
-    const taken = seen.get(transition.id);
-    seen.set(transition.id, (taken ?? 0) + 1);
-    return taken === void 0 ? transition : { ...transition, id: `${transition.id}#${taken + 1}` };
-  });
+function chargeBudget(state) {
+  state.pathCount++;
+  if (state.pathCount > MAX_PATHS) {
+    throw new PathBudgetExceeded(
+      `path budget exceeded, more than ${MAX_PATHS} paths`
+    );
+  }
 }
-
-// src/effectGuards.ts
-var keyOf = (condition) => `${condition.polarity}:${condition.sourceText}`;
-var opposite = (condition) => `${condition.polarity === "positive" ? "negative" : "positive"}:${condition.sourceText}`;
-function guardsHoldOn(preconditions, conditions) {
-  if (preconditions === void 0 || preconditions.length === 0) {
+function recordTerminal(ctx, terminal, home, path4) {
+  chargeBudget(ctx.state);
+  const info = classify(path4, home, ctx.isAncestorOrSelf);
+  const existing = ctx.state.byTerminal.get(terminal) ?? [];
+  existing.push(info);
+  ctx.state.byTerminal.set(terminal, existing);
+}
+function containsTerminal(ctx, stmt) {
+  if ((ctx.terminalsByStmt.get(stmt)?.length ?? 0) > 0) {
     return true;
   }
-  const onBranch = new Set(conditions.map(keyOf));
-  return preconditions.every(
-    (precondition) => !onBranch.has(opposite(precondition))
-  );
+  return childrenOf(stmt).some((child) => containsTerminal(ctx, child));
 }
-function runsBefore(effectLine, terminalEndLine) {
-  return effectLine <= terminalEndLine;
+function stepIf(stmt, path4, ctx) {
+  const thenExit = exitKindOfList(stmt.thenBody);
+  const elseExit = stmt.elseBody === null ? null : exitKindOfList(stmt.elseBody);
+  const thenPath = [
+    ...path4,
+    branchCond(stmt, stmt.condition, "positive", elseExit)
+  ];
+  const elsePath = [
+    ...path4,
+    branchCond(
+      stmt,
+      stmt.condition,
+      "negative",
+      stmt.elseBody === null ? thenExit : null
+    )
+  ];
+  const out = [];
+  out.push(...enumerate(ctx, stmt.thenBody, thenPath));
+  if (stmt.elseBody !== null) {
+    out.push(...enumerate(ctx, stmt.elseBody, elsePath));
+  } else {
+    out.push(elsePath);
+  }
+  return out;
 }
-
-// src/moduleImports.ts
-function stampModuleImports(summaries, importsOf) {
-  const byFile = /* @__PURE__ */ new Map();
-  for (const summary of summaries) {
-    const file = summary.location.file;
-    if (!byFile.has(file)) {
-      const found = importsOf(file);
-      byFile.set(
-        file,
-        found === void 0 ? void 0 : [...new Set(found)].sort()
-      );
+function stepSwitch(stmt, path4, ctx) {
+  const out = [];
+  const negations = [];
+  let defaultRanBody = false;
+  for (let i = 0; i < stmt.groups.length; i++) {
+    const group = stmt.groups[i];
+    const fallthroughSafe = i === stmt.groups.length - 1;
+    if (hasStrayBreak(group.body)) {
+      throw new UnmodeledFlow("non-trailing break in switch clause");
     }
-    const imports = byFile.get(file);
-    if (imports === void 0) {
-      continue;
+    const groupPath = group.condition === null ? [...path4, ...negations] : [...path4, fixedCond(group.condition, "positive", "explicit")];
+    const conts = enumerate(ctx, group.body, groupPath);
+    if (conts.length > 0) {
+      if (!group.hasTrailingBreak && !fallthroughSafe) {
+        throw new UnmodeledFlow("fallthrough into a non-empty switch clause");
+      }
+      out.push(...conts);
+    }
+    if (group.condition === null) {
+      defaultRanBody = true;
+    } else {
+      const exit = exitKindOfList(group.body);
+      const negationSource = exit === "throw" ? "earlyThrow" : exit === "return" ? "earlyReturn" : "explicit";
+      negations.push(fixedCond(group.condition, "negative", negationSource));
     }
-    summary.metadata = {
-      ...summary.metadata ?? {},
-      moduleImports: imports
-    };
   }
+  if (!defaultRanBody) {
+    out.push([...path4, ...negations]);
+  }
+  return out;
 }
-
-// src/moduleInit.ts
-function moduleInitStructure(options) {
-  const { name, file, range, effects } = options;
-  return {
-    identity: {
-      name,
-      kind: "module-init",
-      file,
-      range,
-      exportName: null,
-      exportPath: null
-    },
-    boundaryBinding: null,
-    parameters: [],
-    branches: [
-      {
-        conditions: [],
-        terminal: {
-          kind: "void",
-          statusCode: null,
-          body: null,
-          exceptionType: null,
-          message: null,
-          component: null,
-          renderTree: null,
-          delegateTarget: null,
-          emitEvent: null,
-          location: range
-        },
-        effects: [],
-        extraEffects: effects,
-        location: range,
-        isDefault: true
-      }
-    ],
-    unmatchedReturns: 0,
-    dependencyCalls: [],
-    declaredContract: null
-  };
-}
-
-// src/packHelpers.ts
-function httpRouteDiscovery(opts) {
-  const kind = opts.kind ?? "handler";
-  const calls = opts.importNames.map((importName) => ({
-    kind,
-    match: {
-      type: "registrationCall",
-      importModule: opts.importModule,
-      importName,
-      registrationChain: [...opts.methods]
-    },
-    bindingExtraction: {
-      // `.all` registers every method, so it records "*", which the pairing
-      // engine treats as agreeing with any method at all.
-      method: {
-        type: "fromRegistration",
-        position: "methodName",
-        nameMap: { all: "*" }
-      },
-      path: { type: "fromArgument", position: 0 }
-    },
-    ...opts.mount !== void 0 ? { mount: opts.mount } : {},
-    requiresImport: [opts.importModule]
-  }));
-  if (opts.importNames.length === 0) {
-    return calls;
+function stepLoop(stmt, path4, ctx) {
+  const bodyExit = exitKindOfList(stmt.body);
+  if (containsTerminal(ctx, stmt)) {
+    enumerate(ctx, stmt.body, [
+      ...path4,
+      loopIterationCond(stmt.condition.sourceText)
+    ]);
   }
-  return [
-    ...calls,
-    // Routes registered in a loop over an array of specs, a shape
-    // registration-call discovery cannot see. The receiver comes from
-    // the same import declaration as the calls above, so a loop that
-    // never touches this library's routable is left alone.
-    {
-      kind,
-      match: {
-        type: "registrationLoop",
-        elementShape: LOOP_ELEMENT_SHAPE,
-        receiver: {
-          importModule: opts.importModule,
-          importNames: [...opts.importNames]
-        }
-      },
-      requiresImport: [opts.importModule]
+  if (bodyExit !== null) {
+    return [[...path4, loopCompletedCond(stmt.condition.sourceText, bodyExit)]];
+  }
+  return [path4];
+}
+function stepTry(stmt, path4, ctx) {
+  if (stmt.finallyBody !== null) {
+    const finallyHasTerminal = stmt.finallyBody.some(
+      (s) => containsTerminal(ctx, s)
+    );
+    if (exitKindOfList(stmt.finallyBody) !== null || finallyHasTerminal) {
+      throw new UnmodeledFlow("finally block with exits or terminals");
     }
-  ];
+  }
+  const out = [];
+  out.push(...enumerate(ctx, stmt.tryBody, path4));
+  if (stmt.catchBody !== null) {
+    const catchPath = [...path4, catchEntryCond()];
+    out.push(...enumerate(ctx, stmt.catchBody, catchPath));
+  }
+  return out;
 }
-function wrapperDiscovery(opts) {
-  return opts.importNames.flatMap(
-    (importName) => opts.wraps.map((wraps) => ({
-      kind: opts.kind ?? "middleware",
-      match: {
-        type: "registrationCall",
-        importModule: opts.importModule,
-        importName,
-        registrationChain: []
-      },
-      wraps: { ...wraps },
-      requiresImport: [opts.importModule]
-    }))
-  );
+function stepExit(stmt, path4, ctx) {
+  const collector = ctx.state.callbackExits[ctx.state.callbackExits.length - 1];
+  if (collector !== void 0 && (stmt.exit === "return" || stmt.exit === "throw")) {
+    collector.push(path4);
+  }
+  return [];
 }
-var LOOP_ELEMENT_SHAPE = {
-  methodKey: "method",
-  pathKey: "path",
-  handlerKey: "handler"
-};
-function registrationHelperDiscovery(helpers, kind = "handler") {
-  return helpers.map((helper) => ({
-    kind,
-    match: {
-      type: "registrationTemplate",
-      helperName: helper.helperName,
-      ...helper.importModule !== void 0 ? { importModule: helper.importModule } : {},
-      ...helper.subject !== void 0 ? { subject: helper.subject } : {},
-      registrations: helper.registrations.map((one) => ({ ...one }))
-    }
-  }));
+function stepOpaque(_stmt, path4, _ctx) {
+  return [path4];
+}
+var stepHandlers = {
+  if: stepIf,
+  switch: stepSwitch,
+  loop: stepLoop,
+  try: stepTry,
+  exit: stepExit,
+  opaque: stepOpaque
+};
+function stepCallback(ctx, body, path4) {
+  const exits = [];
+  ctx.state.callbackExits.push(exits);
+  let fellThrough;
+  try {
+    fellThrough = enumerate(ctx, body, path4);
+  } finally {
+    ctx.state.callbackExits.pop();
+  }
+  const out = [...fellThrough, ...exits];
+  return out.length === 0 ? [path4] : out;
 }
-function routeHelperIndex(opts) {
-  const methods = new Set(
-    opts.methods.map(
-      (method) => method.startsWith(".") ? method.slice(1) : method
+function stepStatement(ctx, stmt, path4) {
+  let paths = [path4];
+  for (const body of stmt.callbacks ?? []) {
+    paths = paths.flatMap((each) => stepCallback(ctx, body, each));
+  }
+  const ownTerminals = ctx.terminalsByStmt.get(stmt) ?? [];
+  for (const each of withRejoined(paths)) {
+    for (const terminal of ownTerminals) {
+      recordTerminal(ctx, terminal, stmt, each);
+    }
+  }
+  const handler = stepHandlers[stmt.kind];
+  return paths.flatMap(
+    (each) => handler(
+      stmt,
+      each,
+      ctx
     )
   );
-  return {
-    find: { by: "subject" },
-    declare: (helpers) => ({
-      discovery: registrationHelperDiscovery(
-        helpers.flatMap((helper) => routesRegisteredBy(helper, methods, opts)),
-        opts.kind ?? "handler"
-      )
-    })
-  };
 }
-function routesRegisteredBy(helper, methods, opts) {
-  const registrations = [];
-  let subjectArgument;
-  for (const sink of helper.sinks) {
-    const registration = routeRegisteredBy(helper, sink, methods);
-    if (registration === null) {
+function soleDisagreement(left, right) {
+  if (left.length !== right.length) {
+    return null;
+  }
+  let found = null;
+  for (let at = 0; at < left.length; at++) {
+    const one = left[at];
+    const other = right[at];
+    if (one === other) {
       continue;
     }
-    registrations.push(registration);
-    if (sink.receiver.as === "parameter") {
-      subjectArgument = sink.receiver.position;
+    if (found !== null) {
+      return null;
     }
-  }
-  if (registrations.length === 0 || subjectArgument === void 0) {
-    return [];
-  }
-  return [
-    {
-      helperName: helper.name,
-      importModule: helper.file,
-      subject: {
-        argument: subjectArgument,
-        importModule: opts.importModule,
-        importNames: [...opts.importNames]
-      },
-      registrations
+    if (one === void 0 || other === void 0 || one.branchStmt === null || one.branchStmt !== other.branchStmt || one.info.polarity === other.info.polarity) {
+      return null;
     }
-  ];
+    found = at;
+  }
+  return found;
 }
-function routeRegisteredBy(helper, sink, methods) {
-  if (sink.method === null || !methods.has(sink.method)) {
-    return null;
+function mergeRejoined(paths) {
+  let current = paths;
+  for (let round = 0; round < current.length; round++) {
+    const out = [];
+    const taken = /* @__PURE__ */ new Set();
+    let mergedAny = false;
+    for (let i = 0; i < current.length; i++) {
+      if (taken.has(i)) {
+        continue;
+      }
+      let combined = current[i];
+      for (let j = i + 1; j < current.length; j++) {
+        if (taken.has(j)) {
+          continue;
+        }
+        const at = soleDisagreement(combined, current[j]);
+        if (at === null) {
+          continue;
+        }
+        combined = [...combined.slice(0, at), ...combined.slice(at + 1)];
+        taken.add(j);
+        mergedAny = true;
+        break;
+      }
+      out.push(combined);
+    }
+    current = out;
+    if (!mergedAny) {
+      break;
+    }
   }
-  const { receiver } = sink;
-  if (receiver.as !== "parameter" || receiver.property !== void 0 || !helper.subjectParameters.includes(receiver.position)) {
-    return null;
+  return current;
+}
+function withRejoined(paths) {
+  const merged = mergeRejoined(paths);
+  return merged.length === paths.length ? paths : [...merged, ...paths];
+}
+function enumerate(ctx, stmts, prefix) {
+  let frontiers = [[...prefix]];
+  for (const stmt of stmts) {
+    const nextFrontiers = [];
+    for (const path4 of mergeRejoined(frontiers)) {
+      nextFrontiers.push(...stepStatement(ctx, stmt, path4));
+    }
+    frontiers = nextFrontiers;
+    if (frontiers.length > MAX_PATHS) {
+      throw new PathBudgetExceeded(
+        `path budget exceeded, more than ${MAX_PATHS} paths`
+      );
+    }
+    if (frontiers.length === 0) {
+      break;
+    }
   }
-  const pathTemplate = sink.arguments[0];
-  const handler = sink.arguments[sink.arguments.length - 1];
-  if (sink.arguments.length < 2 || pathTemplate === void 0 || pathTemplate.as !== "text" || handler === void 0) {
-    return null;
+  return frontiers;
+}
+function buildParentMap(statements) {
+  const parentOf = /* @__PURE__ */ new Map();
+  const visit = (stmt, parent) => {
+    parentOf.set(stmt, parent);
+    for (const child of childrenOf(stmt)) {
+      visit(child, stmt);
+    }
+  };
+  for (const stmt of statements) {
+    visit(stmt, null);
   }
-  const handlerArg = handlerSlot(handler);
-  return handlerArg === null ? null : {
-    // `.all` registers every method, which the pairing engine
-    // spells as a wildcard.
-    method: sink.method === "all" ? "*" : sink.method.toUpperCase(),
-    pathTemplate: pathTemplate.text,
-    handlerArg
+  return parentOf;
+}
+function enumerateStructuredPaths(input) {
+  const parentOf = buildParentMap(input.statements);
+  const isAncestorOrSelf = (a, b) => {
+    let current = b;
+    while (current !== null) {
+      if (current === a) {
+        return true;
+      }
+      current = parentOf.get(current) ?? null;
+    }
+    return false;
+  };
+  const state = {
+    byTerminal: /* @__PURE__ */ new Map(),
+    fallthrough: [],
+    pathCount: 0,
+    callbackExits: []
+  };
+  const ctx = {
+    terminalsByStmt: input.terminalsByStmt,
+    state,
+    isAncestorOrSelf
   };
+  const continuations = withRejoined(enumerate(ctx, input.statements, []));
+  for (const path4 of continuations) {
+    chargeBudget(state);
+    state.fallthrough.push(classify(path4, null, isAncestorOrSelf));
+  }
+  return { byTerminal: state.byTerminal, fallthrough: state.fallthrough };
 }
-function handlerSlot(value) {
-  if (value.as !== "parameter") {
-    return null;
+function enumerateOrDegrade(input, terminals) {
+  try {
+    return { ...enumerateStructuredPaths(input), degraded: null };
+  } catch (error) {
+    const reason = reasonToDegrade(error);
+    if (reason === null) {
+      throw error;
+    }
+    const marker = {
+      sourceText: `unmodeled control flow (${reason})`,
+      polarity: "positive",
+      source: "explicit",
+      expression: null
+    };
+    const byTerminal = /* @__PURE__ */ new Map();
+    for (const terminal of terminals) {
+      byTerminal.set(terminal, [[marker]]);
+    }
+    return { byTerminal, fallthrough: [[marker]], degraded: reason };
   }
-  return value.property === void 0 ? `{${value.position}}` : `{${value.position}}.${value.property}`;
 }
-function unwrapJsonStringify(body) {
-  if (body === null || typeof body !== "object") {
-    return body;
+function reasonToDegrade(error) {
+  if (error instanceof PathBudgetExceeded) {
+    return error.message === "" ? "path budget exceeded" : error.message;
   }
-  const candidate = body;
-  if (candidate.kind !== "call" || candidate.callee !== "JSON.stringify") {
-    return body;
+  if (error instanceof UnmodeledFlow) {
+    return error.message;
   }
-  const inner = candidate.args?.[0];
-  return inner ?? body;
+  return null;
 }
 
-// src/packOptions.ts
-import { z } from "zod";
-var storageSystemOption = z.enum([
-  "postgresql",
-  "mysql",
-  "sqlite"
-]);
-var scopeOption = z.string();
-var configuredCallOption = z.object({
-  /** Module that declares the receiver's type. */
-  module: z.string(),
-  /** Type name of the receiver, as exported from that module. */
-  receiver: z.string(),
-  /** Method that performs the send. */
-  method: z.string(),
-  /** Argument index carrying the subject. */
-  subjectArg: z.number(),
-  /**
-   * Which argument the message body is. Left out when the method has no
-   * single body argument, as a batch method taking a list of entries
-   * does, and then no body is reported.
-   */
-  bodyArg: z.number().optional()
-}).strict();
-
 // src/paths/gatingConditions.ts
 var keyOf2 = (condition) => `${condition.polarity}:${condition.sourceText}`;
 function sharedGatingConditions(paths, readPredicate) {