@suss/extractor 0.19.0 → 0.21.0

package/README.md

@@ -58,6 +58,53 @@ const summary = assembleSummary(raw);
 // summary.transitions[0].output.type === "response"
 ```
 
+## Composing the wrappers around a unit
+
+A route's wire behaviour is not only what its own body does. Middleware, error handlers and validation hooks produce responses for it without appearing in it, which is why a service whose auth middleware returns 401 used to look like every route disagreed with its contract.
+
+A wrapper is a meta-function: it takes a unit and returns a unit. Its own body says what it does once you know which call is the continuation, so the adapter reads the call to that parameter as a `delegate` terminal. A path through the wrapper that reaches it hands control to the wrapped unit; a path that ends first responds on its own.
+
+```
+composed = the wrapper's short circuits
+         + (its pass-throughs x the wrapped unit's transitions)
+```
+
+`composeWrappers` runs that over a whole run's summaries. It reads the `wrappers` metadata a unit records, finds each wrapper's summary by file and name, and folds them innermost first, the way `mw1(mw2(handler))` reads. A wrapper the framework only calls on a throw goes on last and replaces the paths that ended by throwing with its own response. Every transition a wrapper contributed records which one, under `wrappers.from`, so a reader asking why a route returns 401 lands in the middleware.
+
+What it does not read:
+
+- **Anything after the continuation returns.** A middleware that inspects the response on the way back out is read up to the `next()` call and no further.
+- **A wrapper whose continuation the pack does not declare, or whose call the walk cannot see.** Nothing says where control passes on, so the wrapper's outcomes are reported beside the unit's own rather than around them.
+- **A throw the walk never saw.** An error handler composes over the paths that end by throwing, so a route whose 500 comes from a call the walk could not follow still does not report 500.
+- **Registration order against route order.** A wrapper registered after a route still composes into it.
+
+Composition multiplies paths, so it is capped by the same `MAX_PATHS` budget path enumeration uses. Past it the two sides are reported side by side and the unit gets a gap saying so.
+
+## Which branch an effect belongs to
+
+An adapter finds the calls a body makes once, and it finds the branches separately. Something then has to say which branch each call runs on. `guardsHoldOn` and `runsBefore` in `effectGuards.ts` are that decision, and both adapters that make it call these rather than keeping a copy.
+
+A call belongs to a branch when two things are true of it.
+
+- **No guard the call is written under was recorded the other way around on the branch.** A call inside `if (flag)` stays off every branch that recorded `!flag`. A call written above every guard has none, so it reaches all of them.
+- **The call is written no later than the terminal's last line.** A call written after an early return did not run on that early return's path. The terminal's last line and not its first, because `return new Promise((resolve) => resolve(read()))` runs the call inside its own expression.
+
+Neither test is enough on its own, and the two ways to get it wrong are both ordinary code.
+
+```ts
+const found = await dynamo.send(new GetItemCommand({ TableName: "Invoices" }));
+if (!found.Item) {
+  return { statusCode: 404, body: JSON.stringify({ error: "no invoice" }) };
+}
+return { statusCode: 200, body: JSON.stringify({ invoice: found.Item }) };
+```
+
+The read is under no guard, so guards alone put it on both branches, which is right. Source order alone would too. But `JSON.stringify` inside the 404 return is under `!found.Item`, and its line comes before the 200 return, so source order alone would put it on the 200 branch, where it never ran. Guards catch that. Turn the example around, put the read after the 404 return, and guards alone put it on the 404 branch, where it also never ran. Source order catches that.
+
+The first test asks whether the branch contradicts the guard, not whether the branch repeats it. That matters because a branch often cannot speak about a guard at all. The path engine opacifies a loop, so a terminal after the loop records nothing about an `if` inside the loop body, and the same goes for a call inside a `catch` or inside a callback the walk descended into. The commonest shape in this repo is an accumulator: a loop that pushes into an array under a condition, then returns the array. Requiring the branch to repeat the guard takes those pushes off the only branch there is, and the unit comes out calling nothing at all. So silence on the branch leaves the effect in place, and only a guard written down the other way around takes it off.
+
+Comparison is by the condition's polarity and the text it was written as, the same key a transition id is built from. An adapter therefore has to spell a guard on an effect the way it spells the same guard on a branch, or the two never meet and the guard is treated as silence.
+
 ## Coverage
 
 ![coverage](../../.github/badges/coverage-extractor.svg)

package/dist/index.cjs

@@ -22,33 +22,45 @@ var index_exports = {};
 __export(index_exports, {
   IdMap: () => IdMap,
   IdSet: () => IdSet,
+  MAX_PATHS: () => MAX_PATHS,
   PathBudgetExceeded: () => PathBudgetExceeded,
+  SKIP_CHILDREN: () => SKIP_CHILDREN,
   UnmodeledFlow: () => UnmodeledFlow,
   absentReading: () => absentReading,
   ambiguousReading: () => ambiguousReading,
   andThenReading: () => andThenReading,
   assembleSummary: () => assembleSummary,
   assessConfidence: () => assessConfidence,
+  composeWrappers: () => composeWrappers,
+  configuredCallOption: () => configuredCallOption,
   detectGaps: () => detectGaps,
   effectToIR: () => effectToIR,
   enumerateOrDegrade: () => enumerateOrDegrade,
   enumerateStructuredPaths: () => enumerateStructuredPaths,
   firstWrittenReading: () => firstWrittenReading,
+  guardsHoldOn: () => guardsHoldOn,
   httpRouteDiscovery: () => httpRouteDiscovery,
   makeTransitionId: () => makeTransitionId,
   mapReading: () => mapReading,
   paramToInput: () => paramToInput,
+  rawConditionToPredicate: () => rawConditionToPredicate,
   registrationHelperDiscovery: () => registrationHelperDiscovery,
+  routeHelperIndex: () => routeHelperIndex,
+  runsBefore: () => runsBefore,
+  scopeOption: () => scopeOption,
   sharedGatingConditions: () => sharedGatingConditions,
+  storageSystemOption: () => storageSystemOption,
   terminalToOutput: () => terminalToOutput,
   unreadableReading: () => unreadableReading,
   unwrapJsonStringify: () => unwrapJsonStringify,
   valueToReadFurtherFrom: () => valueToReadFurtherFrom,
+  walkDescendants: () => walkDescendants,
+  wrapperDiscovery: () => wrapperDiscovery,
   writtenReading: () => writtenReading
 });
 module.exports = __toCommonJS(index_exports);
 var import_node_crypto = require("crypto");
-var import_behavioral_ir2 = require("@suss/behavioral-ir");
+var import_behavioral_ir3 = require("@suss/behavioral-ir");
 
 // src/inputReads.ts
 function inputReadsOf(args) {
@@ -140,80 +152,8 @@ function mergeInputReads(derived, syntactic) {
   return [...found.values()];
 }
 
-// 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 [
-    ...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]
-    }
-  ];
-}
-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 } : {},
-      registrations: helper.registrations.map((one) => ({ ...one }))
-    }
-  }));
-}
-function unwrapJsonStringify(body) {
-  if (body === null || typeof body !== "object") {
-    return body;
-  }
-  const candidate = body;
-  if (candidate.kind !== "call" || candidate.callee !== "JSON.stringify") {
-    return body;
-  }
-  const inner = candidate.args?.[0];
-  return inner ?? body;
-}
+// src/composeWrappers.ts
+var import_behavioral_ir2 = require("@suss/behavioral-ir");
 
 // src/paths/enumeratePaths.ts
 var import_behavioral_ir = require("@suss/behavioral-ir");
@@ -630,23 +570,372 @@ function reasonToDegrade(error) {
   return null;
 }
 
-// src/paths/gatingConditions.ts
+// 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`
+};
+function composeWrappers(summaries) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const summary of summaries) {
+    const key = summaryKey(summary.location.file, summary.identity.name);
+    if (!byKey.has(key)) {
+      byKey.set(key, summary);
+    }
+  }
+  return summaries.map((summary) => composeOne(summary, byKey));
+}
+function summaryKey(file, name) {
+  return `${file}::${name}`;
+}
+function composeOne(summary, byKey) {
+  const recorded = (0, import_behavioral_ir2.readWrapperMetadata)(summary);
+  const applied = recorded?.applied ?? [];
+  const covering = applied.filter(
+    (reference) => coversUnit(reference, summary)
+  );
+  const narrowed = covering.length === applied.length ? summary : {
+    ...summary,
+    metadata: (0, import_behavioral_ir2.withWrapperMetadata)(summary.metadata, {
+      applied: covering
+    })
+  };
+  const wrappers = covering.flatMap((reference) => {
+    const found = byKey.get(summaryKey(reference.file, reference.name));
+    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));
+  }
+  if (composition.transitions === summary.transitions) {
+    return narrowed;
+  }
+  return {
+    ...narrowed,
+    transitions: withDistinctIds(composition.transitions),
+    gaps: composition.degraded ? [...summary.gaps, BUDGET_GAP] : summary.gaps
+  };
+}
+function merge(before, step) {
+  return {
+    transitions: step.transitions,
+    degraded: before.degraded || step.degraded
+  };
+}
+function coversUnit(reference, summary) {
+  if (reference.scope === void 0) {
+    return true;
+  }
+  const binding = summary.identity.boundaryBinding;
+  return binding !== null && (0, import_behavioral_ir2.withinScope)(binding, reference.scope);
+}
+function applyWrapper(wrapper, inner) {
+  const shortCircuits = attribute(
+    wrapper.summary.transitions.filter((t) => t.output.type !== "delegate"),
+    wrapper.reference
+  );
+  const passThroughs = 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 };
+}
+function applyThrowWrapper(wrapper, inner) {
+  const thrown = inner.transitions.filter((t) => t.output.type === "throw");
+  if (thrown.length === 0) {
+    return inner;
+  }
+  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
+    };
+  }
+  const composed = thrown.flatMap(
+    (transition) => attribute(
+      handled.map((handler) => splice(transition, handler)),
+      wrapper.reference
+    )
+  );
+  return { transitions: [...rest, ...composed], degraded: false };
+}
+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 attribute(transitions, reference) {
+  return transitions.map((transition) => ({
+    ...transition,
+    metadata: (0, import_behavioral_ir2.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;
+  }
+  const onBranch = new Set(conditions.map(keyOf));
+  return preconditions.every(
+    (precondition) => !onBranch.has(opposite(precondition))
+  );
+}
+function runsBefore(effectLine, terminalEndLine) {
+  return effectLine <= terminalEndLine;
+}
+
+// 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 [
+    ...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 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 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 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 routesRegisteredBy(helper, methods, opts) {
+  const registrations = [];
+  let subjectArgument;
+  for (const sink of helper.sinks) {
+    const registration = routeRegisteredBy(helper, sink, methods);
+    if (registration === null) {
+      continue;
+    }
+    registrations.push(registration);
+    if (sink.receiver.as === "parameter") {
+      subjectArgument = sink.receiver.position;
+    }
+  }
+  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 routeRegisteredBy(helper, sink, methods) {
+  if (sink.method === null || !methods.has(sink.method)) {
+    return null;
+  }
+  const { receiver } = sink;
+  if (receiver.as !== "parameter" || receiver.property !== void 0 || !helper.subjectParameters.includes(receiver.position)) {
+    return 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;
+  }
+  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
+  };
+}
+function handlerSlot(value) {
+  if (value.as !== "parameter") {
+    return null;
+  }
+  return value.property === void 0 ? `{${value.position}}` : `{${value.position}}.${value.property}`;
+}
+function unwrapJsonStringify(body) {
+  if (body === null || typeof body !== "object") {
+    return body;
+  }
+  const candidate = body;
+  if (candidate.kind !== "call" || candidate.callee !== "JSON.stringify") {
+    return body;
+  }
+  const inner = candidate.args?.[0];
+  return inner ?? body;
+}
+
+// src/packOptions.ts
+var import_zod = require("zod");
+var storageSystemOption = import_zod.z.enum([
+  "postgresql",
+  "mysql",
+  "sqlite"
+]);
+var scopeOption = import_zod.z.string();
+var configuredCallOption = import_zod.z.object({
+  /** Module that declares the receiver's type. */
+  module: import_zod.z.string(),
+  /** Type name of the receiver, as exported from that module. */
+  receiver: import_zod.z.string(),
+  /** Method that performs the send. */
+  method: import_zod.z.string(),
+  /** Argument index carrying the subject. */
+  subjectArg: import_zod.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: import_zod.z.number().optional()
+}).strict();
+
+// src/paths/gatingConditions.ts
+var keyOf2 = (condition) => `${condition.polarity}:${condition.sourceText}`;
 function sharedGatingConditions(paths, readPredicate) {
   const [first, ...rest] = paths ?? [];
   if (first === void 0) {
     return [];
   }
-  const shared = new Set(first.map(keyOf));
+  const shared = new Set(first.map(keyOf2));
   for (const path of rest) {
-    const here = new Set(path.map(keyOf));
+    const here = new Set(path.map(keyOf2));
     for (const value of shared) {
       if (!here.has(value)) {
         shared.delete(value);
       }
     }
   }
-  return first.filter((condition) => shared.has(keyOf(condition))).map((condition) => ({
+  return first.filter((condition) => shared.has(keyOf2(condition))).map((condition) => ({
     sourceText: condition.sourceText,
     structured: readPredicate === void 0 || condition.expression === null ? null : readPredicate(condition.expression),
     polarity: condition.polarity,
@@ -700,6 +989,21 @@ var IdMap = class {
   }
 };
 
+// src/paths/nodeWalk.ts
+var SKIP_CHILDREN = /* @__PURE__ */ Symbol("skipChildren");
+function walkDescendants(root, carried, visitor) {
+  for (const child of root.namedChildren) {
+    if (child === null) {
+      continue;
+    }
+    visitor.at(child, carried);
+    const inner = visitor.into(child, carried);
+    if (inner !== SKIP_CHILDREN) {
+      walkDescendants(child, inner, visitor);
+    }
+  }
+}
+
 // src/reading.ts
 function writtenReading(value, range) {
   return { kind: "written", value, range };
@@ -866,6 +1170,7 @@ function assembleSummary(raw, options = DEFAULT_OPTIONS) {
     location: {
       file: raw.identity.file,
       range: raw.identity.range,
+      ...raw.identity.span !== void 0 ? { span: raw.identity.span } : {},
       exportName: raw.identity.exportName
     },
     identity: {
@@ -888,17 +1193,23 @@ function buildMetadata(raw) {
   let metadata = {};
   const http = buildHttpMetadataValue(raw);
   if (http !== null) {
-    metadata = (0, import_behavioral_ir2.withHttpMetadata)(metadata, http);
+    metadata = (0, import_behavioral_ir3.withHttpMetadata)(metadata, http);
   }
   const graphql = buildGraphqlMetadataValue(raw);
   if (graphql !== null) {
-    metadata = (0, import_behavioral_ir2.withGraphqlMetadata)(metadata, graphql);
+    metadata = (0, import_behavioral_ir3.withGraphqlMetadata)(metadata, graphql);
   }
   if (raw.sourceDocumentLabel !== void 0) {
-    metadata = (0, import_behavioral_ir2.withSourceDocumentMetadata)(metadata, {
+    metadata = (0, import_behavioral_ir3.withSourceDocumentMetadata)(metadata, {
       label: raw.sourceDocumentLabel
     });
   }
+  if (raw.mount !== void 0) {
+    metadata = (0, import_behavioral_ir3.withMountMetadata)(metadata, raw.mount);
+  }
+  if (raw.wrappers !== void 0 && raw.wrappers.length > 0) {
+    metadata = (0, import_behavioral_ir3.withWrapperMetadata)(metadata, { applied: raw.wrappers });
+  }
   return Object.keys(metadata).length > 0 ? metadata : null;
 }
 function buildHttpMetadataValue(raw) {
@@ -947,7 +1258,7 @@ function answersWithHttpResponses(raw) {
   if (raw.boundaryBinding === null || raw.boundaryBinding === void 0) {
     return true;
   }
-  return (0, import_behavioral_ir2.exchangesHttpResponses)(raw.boundaryBinding);
+  return (0, import_behavioral_ir3.exchangesHttpResponses)(raw.boundaryBinding);
 }
 function detectGaps(raw, transitions, options) {
   if (options.gapHandling === "silent") {
@@ -1162,27 +1473,39 @@ function paramToInput(param) {
 0 && (module.exports = {
   IdMap,
   IdSet,
+  MAX_PATHS,
   PathBudgetExceeded,
+  SKIP_CHILDREN,
   UnmodeledFlow,
   absentReading,
   ambiguousReading,
   andThenReading,
   assembleSummary,
   assessConfidence,
+  composeWrappers,
+  configuredCallOption,
   detectGaps,
   effectToIR,
   enumerateOrDegrade,
   enumerateStructuredPaths,
   firstWrittenReading,
+  guardsHoldOn,
   httpRouteDiscovery,
   makeTransitionId,
   mapReading,
   paramToInput,
+  rawConditionToPredicate,
   registrationHelperDiscovery,
+  routeHelperIndex,
+  runsBefore,
+  scopeOption,
   sharedGatingConditions,
+  storageSystemOption,
   terminalToOutput,
   unreadableReading,
   unwrapJsonStringify,
   valueToReadFurtherFrom,
+  walkDescendants,
+  wrapperDiscovery,
   writtenReading
 });