@agenteer/stdlib 1.0.0-rc.1

package/src/index.ts

@@ -0,0 +1,149 @@
+/**
+ * @agenteer/stdlib — v1 standard library (M5 adds ask_user: 19 nodes).
+ *
+ *   Primitives (5):  file_read, file_write, shell_exec, llm_call, tool_call
+ *   Validators (5):  compile, test_run, regex_check, typecheck, json_schema_validate
+ *   Meta (4):        parallel_fanout, cross_check, judge_with_stripped_ctx, repair_loop
+ *   Humans (2):      approval_gate, ask_user (M5)
+ *   Planner (1):     default_planner
+ *   Context (1):     context_curator
+ *
+ * `registerStdlib` registers M2-shape nodes (file_read/write/shell_exec/
+ * json_schema_validate/llm_call). Nodes with external dependencies
+ * (provider/resolver/tool registry) are exported as factories for the
+ * caller to wire and register individually.
+ */
+
+import type { NodeRegistry } from "@agenteer/core";
+
+// Primitives
+import { fileReadFactory, fileReadManifest } from "./primitives/file_read.js";
+import { fileWriteFactory, fileWriteManifest } from "./primitives/file_write.js";
+import { shellExecFactory, shellExecManifest } from "./primitives/shell_exec.js";
+import { llmCallFactory, llmCallManifest } from "./primitives/llm_call.js";
+import { toolCallFactory, toolCallManifest } from "./primitives/tool_call.js";
+
+// Validators
+import {
+  jsonSchemaValidateFactory,
+  jsonSchemaValidateManifest,
+} from "./validators/json_schema_validate.js";
+import { regexCheckFactory, regexCheckManifest } from "./validators/regex_check.js";
+import { compileFactory, compileManifest } from "./validators/compile.js";
+import { testRunFactory, testRunManifest } from "./validators/test_run.js";
+import { typecheckFactory, typecheckManifest } from "./validators/typecheck.js";
+
+// Meta
+import { parallelFanoutFactory, parallelFanoutManifest } from "./meta/parallel_fanout.js";
+import { crossCheckFactory, crossCheckManifest } from "./meta/cross_check.js";
+import {
+  judgeWithStrippedCtxFactory,
+  judgeWithStrippedCtxManifest,
+} from "./meta/judge_with_stripped_ctx.js";
+import { repairLoopFactory, repairLoopManifest } from "./meta/repair_loop.js";
+
+// Context, humans, planner
+import { contextCuratorFactory, contextCuratorManifest } from "./context/context_curator.js";
+import { approvalGateFactory, approvalGateManifest } from "./humans/approval_gate.js";
+import { askUserFactory, askUserManifest } from "./humans/ask_user.js";
+import { defaultPlannerFactory, defaultPlannerManifest } from "./planner/default_planner.js";
+
+export {
+  // Primitives
+  fileReadFactory,
+  fileReadManifest,
+  fileWriteFactory,
+  fileWriteManifest,
+  shellExecFactory,
+  shellExecManifest,
+  llmCallFactory,
+  llmCallManifest,
+  toolCallFactory,
+  toolCallManifest,
+  // Validators
+  jsonSchemaValidateFactory,
+  jsonSchemaValidateManifest,
+  regexCheckFactory,
+  regexCheckManifest,
+  compileFactory,
+  compileManifest,
+  testRunFactory,
+  testRunManifest,
+  typecheckFactory,
+  typecheckManifest,
+  // Meta
+  parallelFanoutFactory,
+  parallelFanoutManifest,
+  crossCheckFactory,
+  crossCheckManifest,
+  judgeWithStrippedCtxFactory,
+  judgeWithStrippedCtxManifest,
+  repairLoopFactory,
+  repairLoopManifest,
+  // Context / humans / planner
+  contextCuratorFactory,
+  contextCuratorManifest,
+  approvalGateFactory,
+  approvalGateManifest,
+  askUserFactory,
+  askUserManifest,
+  defaultPlannerFactory,
+  defaultPlannerManifest,
+};
+
+export type { CompileAdapter } from "./validators/compile.js";
+export type { TestAdapter, TestReport } from "./validators/test_run.js";
+export type { ApprovalResolver } from "./humans/approval_gate.js";
+export type { AskUserResolver, AskUserFactoryOptions } from "./humans/ask_user.js";
+export type { ProviderResolver } from "./meta/cross_check.js";
+export * from "./shared/index.js";
+
+/**
+ * Register M4 nodes that have zero external wiring. Nodes that need a
+ * provider resolver, tool registry, approval resolver, or response
+ * schema are exported as factories — wire and register them yourself.
+ */
+export function registerStdlib(registry: NodeRegistry): void {
+  // Primitives (except tool_call / llm_call which need wiring)
+  registry.register(fileReadManifest, fileReadFactory);
+  registry.register(fileWriteManifest, fileWriteFactory);
+  registry.register(shellExecManifest, shellExecFactory);
+  registry.register(toolCallManifest, toolCallFactory);
+
+  // Validators
+  registry.register(jsonSchemaValidateManifest, jsonSchemaValidateFactory);
+  registry.register(regexCheckManifest, regexCheckFactory);
+  registry.register(compileManifest, compileFactory);
+  registry.register(testRunManifest, testRunFactory);
+  registry.register(typecheckManifest, typecheckFactory);
+
+  // Meta (parallel_fanout/judge/repair_loop are self-contained)
+  registry.register(parallelFanoutManifest, parallelFanoutFactory);
+  registry.register(judgeWithStrippedCtxManifest, judgeWithStrippedCtxFactory);
+  registry.register(repairLoopManifest, repairLoopFactory);
+
+  // Context + planner
+  registry.register(contextCuratorManifest, contextCuratorFactory);
+  registry.register(defaultPlannerManifest, defaultPlannerFactory);
+}
+
+export const STDLIB_MANIFEST_IDS = [
+  fileReadManifest.id,
+  fileWriteManifest.id,
+  shellExecManifest.id,
+  llmCallManifest.id,
+  toolCallManifest.id,
+  jsonSchemaValidateManifest.id,
+  regexCheckManifest.id,
+  compileManifest.id,
+  testRunManifest.id,
+  typecheckManifest.id,
+  parallelFanoutManifest.id,
+  crossCheckManifest.id,
+  judgeWithStrippedCtxManifest.id,
+  repairLoopManifest.id,
+  contextCuratorManifest.id,
+  approvalGateManifest.id,
+  askUserManifest.id,
+  defaultPlannerManifest.id,
+] as const;

package/src/meta/cross_check.ts

@@ -0,0 +1,219 @@
+/**
+ * `@agenteer/node-cross-check` — meta-node over `trust.CrossCheckEngine`
+ * (sub-plan 03 §11, sub-plan 04 §4.1).
+ *
+ * Three disagreement policies per master plan's ratified resolution:
+ *   - `fail`              → return `Failed("cross_check_disagreement", retryable: true)`.
+ *   - `return_both`       → return `Output({ primary, secondary, disagreement_keys })`.
+ *   - `replace_me_with_judge` → return `ReplaceMe(judge_node)` so a
+ *                               different node decides.
+ *
+ * Retry-on-disagreement uses `ReplaceMe` (sub-plan 00 §7); the engine
+ * itself runs one pass.
+ */
+
+import { z } from "zod";
+import {
+  makeManifest,
+  type Node,
+  type NodeInput,
+  type NodeManifest,
+  type NodeResult,
+  type NodeRuntimeHandle,
+} from "@agenteer/core";
+import {
+  CrossCheckEngine,
+  ComparatorRegistry,
+  DEFAULT_POLICY,
+  StructuredProvider,
+  type CrossCheckOutcome,
+  type CrossCheckPolicy,
+  type ProviderLike,
+} from "@agenteer/trust";
+
+const MANIFEST: NodeManifest = makeManifest({
+  id: "@agenteer/node-cross-check",
+  name: "cross_check",
+  description:
+    "Run the same prompt through two models; surface agreement / disagreement / fallback with policy.",
+  determinism: "stochastic",
+  required_actions: [],
+  dynamic_actions: true,
+  // Synthesizes `model:<primary>` at dispatch; secondary is optional.
+  dynamic_action_spec: "model:${input.primary_model}",
+  tags: ["meta", "llm"],
+  side_effects: {
+    writes_fs: false,
+    network: true,
+    mutates_ctx: true,
+    emits_ctx_variants: ["artifact.cross_check"],
+  },
+});
+
+const InputSchema = z.object({
+  systemPrompt: z.string(),
+  userPrompt: z.string(),
+  schemaName: z.string().min(1),
+  primary_model: z.string().min(1),
+  secondary_model: z.string().optional(),
+  /**
+   * Policy fallbacks; `on_disagreement` picks the meta-node's response:
+   *   - fail: `NodeResult.Failed(retryable: true)` for a parent to retry.
+   *   - return_both: `NodeResult.Output({primary, secondary, disagreement_keys})`.
+   *   - replace_me_with_judge: `NodeResult.ReplaceMe(judge_manifest_id)`.
+   */
+  on_disagreement: z
+    .enum(["fail", "return_both", "replace_me_with_judge"])
+    .default("return_both"),
+  judge_manifest_id: z.string().optional(),
+  temperature: z.number().min(0).max(2).optional(),
+});
+
+const OutputSchema = z.object({
+  outcome: z.enum([
+    "agreement",
+    "disagreement",
+    "missing_secondary_skip",
+    "missing_secondary_fallback_disagreement",
+  ]),
+  value: z.unknown().optional(),
+  primary: z.unknown().optional(),
+  secondary: z.unknown().optional(),
+  disagreement_keys: z.array(z.string()).optional(),
+  fingerprint: z.string().optional(),
+});
+
+type Input = z.input<typeof InputSchema>;
+type Output = z.infer<typeof OutputSchema>;
+
+/**
+ * Factory takes a resolver that maps model ids → ProviderLike instances.
+ * Typical wiring: workflows register their provider adapters once and
+ * hand a resolver to the factory.
+ */
+export interface ProviderResolver {
+  resolve(model_id: string): ProviderLike | null;
+}
+
+export function crossCheckFactory(
+  resolver: ProviderResolver,
+  opts: { policy?: Partial<CrossCheckPolicy>; comparators?: ComparatorRegistry } = {},
+): () => Node<Input, Output> {
+  return () => {
+    const policy: CrossCheckPolicy = { ...DEFAULT_POLICY, ...(opts.policy ?? {}) };
+    const comparators = opts.comparators ?? new ComparatorRegistry();
+    return {
+      manifest: MANIFEST,
+      inputSchema: InputSchema,
+      outputSchema: OutputSchema,
+      ctx: [],
+      model: null,
+      async execute(
+        input: NodeInput<Input>,
+        _handle: NodeRuntimeHandle,
+      ): Promise<NodeResult<Output>> {
+        const i = input.original;
+        const primary = resolver.resolve(i.primary_model);
+        if (!primary) {
+          return {
+            kind: "failed",
+            reason: `no provider registered for primary model '${i.primary_model}'`,
+            retryable: false,
+            evidence: { verdict: "fail" },
+          };
+        }
+        const secondary = i.secondary_model ? resolver.resolve(i.secondary_model) : undefined;
+
+        const engine = new CrossCheckEngine(
+          new StructuredProvider(primary),
+          secondary ? new StructuredProvider(secondary) : undefined,
+          policy,
+          comparators,
+        );
+
+        const outcome = await engine.run({
+          systemPrompt: i.systemPrompt,
+          userPrompt: i.userPrompt,
+          schema: z.unknown() as unknown as z.ZodType<unknown>,
+          schemaName: i.schemaName,
+          ...(i.temperature !== undefined ? { temperature: i.temperature } : {}),
+        });
+
+        return handleOutcome(outcome, i);
+      },
+    };
+  };
+}
+
+export const crossCheckManifest = MANIFEST;
+
+function handleOutcome(
+  outcome: CrossCheckOutcome<unknown>,
+  input: Input,
+): NodeResult<Output> {
+  if (outcome.kind === "agreement") {
+    return {
+      kind: "output",
+      value: { outcome: "agreement", value: outcome.value },
+      evidence: { verdict: "pass" },
+    };
+  }
+  if (outcome.kind === "missing_secondary_skip") {
+    return {
+      kind: "output",
+      value: { outcome: "missing_secondary_skip", value: outcome.value },
+      evidence: { verdict: "pass" },
+    };
+  }
+
+  const primary = outcome.kind === "missing_secondary_fallback_disagreement"
+    ? outcome.primary
+    : (outcome as { primary: unknown }).primary;
+  const secondary = outcome.kind === "missing_secondary_fallback_disagreement"
+    ? outcome.secondFallback
+    : (outcome as { secondary: unknown }).secondary;
+  const disagreement_keys = (outcome as { disagreementKeys?: string[] }).disagreementKeys ?? [];
+  const fingerprint = (outcome as { fingerprint?: string }).fingerprint ?? "";
+
+  const onDis = input.on_disagreement ?? "return_both";
+  if (onDis === "fail") {
+    return {
+      kind: "failed",
+      reason: `cross_check_disagreement:${fingerprint}`,
+      retryable: true,
+      details: { disagreement_keys, primary, secondary },
+      evidence: { verdict: "fail" },
+    };
+  }
+  if (onDis === "replace_me_with_judge") {
+    const judgeId = input.judge_manifest_id ?? "@agenteer/node-judge-with-stripped-ctx";
+    return {
+      kind: "replace_me",
+      reason: `cross_check_disagreement:${fingerprint}`,
+      successor: {
+        manifest_id: judgeId,
+        input: {
+          claim: "cross_check disagreement between primary and secondary outputs",
+          candidates: [primary, secondary],
+          disagreement_keys,
+        },
+        correlation: "cc-judge",
+      },
+    };
+  }
+  // return_both (default)
+  return {
+    kind: "output",
+    value: {
+      outcome:
+        outcome.kind === "missing_secondary_fallback_disagreement"
+          ? "missing_secondary_fallback_disagreement"
+          : "disagreement",
+      primary,
+      secondary,
+      disagreement_keys,
+      fingerprint,
+    },
+    evidence: { verdict: "fail", tool_output: { command: `cross_check:${input.schemaName}` } },
+  };
+}

package/src/meta/judge_with_stripped_ctx.ts

@@ -0,0 +1,171 @@
+/**
+ * `@agenteer/node-judge-with-stripped-ctx` — meta-node that reaches a
+ * verdict on a claim **without the suspect node's reasoning trail**
+ * (sub-plan 03 §13).
+ *
+ * The judge spawns an LLM-backed sub-node with a slice that excludes
+ * `decision` items produced by the suspect (and their derivatives).
+ * Goal: detect motivated reasoning — a judge that still agrees when
+ * stripped of the suspect's narrative has genuine independent support.
+ *
+ * M4 implementation: the slice-filter layer is simple (exclude
+ * `source_node == suspect_node_id` + any `decision` items). A richer
+ * filter (suspect's `derives_from` closure) can land later.
+ */
+
+import { z } from "zod";
+import {
+  makeManifest,
+  type Node,
+  type NodeInput,
+  type NodeManifest,
+  type NodeResult,
+} from "@agenteer/core";
+
+const MANIFEST: NodeManifest = makeManifest({
+  id: "@agenteer/node-judge-with-stripped-ctx",
+  name: "judge_with_stripped_ctx",
+  description:
+    "Reach a verdict on a claim while stripping the suspect node's reasoning trail (decisions + derivatives).",
+  determinism: "stochastic",
+  required_actions: [],
+  dynamic_actions: true,
+  dynamic_action_spec: "spawn:${input.judge_manifest_id}",
+  tags: ["meta"],
+  side_effects: {
+    writes_fs: false,
+    network: true,
+    mutates_ctx: true,
+    emits_ctx_variants: ["artifact.judgment"],
+  },
+});
+
+const InputSchema = z.object({
+  /** What we're judging — free-text claim or a structured marker. */
+  claim: z.string().min(1),
+  /** Candidate answers / verdicts the judge picks between. */
+  candidates: z.array(z.unknown()).min(1),
+  /** Optional hint about which path differed (from cross_check). */
+  disagreement_keys: z.array(z.string()).optional(),
+  /** Manifest of the underlying judge node (usually an llm_call-shaped node). */
+  judge_manifest_id: z.string().default("@agenteer/node-llm-call"),
+  /** Model the judge should use. */
+  judge_model: z.string().optional(),
+});
+
+const OutputSchema = z.object({
+  verdict: z.enum(["candidate_0", "candidate_1", "neither", "cannot_judge"]),
+  chosen: z.unknown().optional(),
+  rationale: z.string(),
+});
+
+type Input = z.input<typeof InputSchema>;
+type Output = z.infer<typeof OutputSchema>;
+
+export function judgeWithStrippedCtxFactory(): Node<Input, Output> {
+  return {
+    manifest: MANIFEST,
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    ctx: [],
+    model: null,
+    async execute(input: NodeInput<Input>): Promise<NodeResult<Output>> {
+      const i = input.original;
+
+      if (!input.children) {
+        const judgePrompt = buildJudgePrompt(i);
+        const judgeManifest = i.judge_manifest_id ?? "@agenteer/node-llm-call";
+        return {
+          kind: "spawn_children",
+          join: { mode: "all" },
+          children: [
+            {
+              manifest_id: judgeManifest,
+              input: {
+                model_id: i.judge_model ?? "mock/judge",
+                prompt: judgePrompt,
+                system:
+                  "You are an impartial reviewer. Pick the candidate you believe is correct. If neither is supportable, answer `neither`. Return JSON.",
+              },
+              correlation: "judge",
+            },
+          ],
+        };
+      }
+
+      const child = input.children[0]!;
+      if (child.result.kind !== "output") {
+        return {
+          kind: "failed",
+          reason: `judge child did not produce output: ${child.result.kind}`,
+          retryable: false,
+          evidence: { verdict: "fail" },
+        };
+      }
+
+      const parsed = parseJudgeOutput((child.result as { value: unknown }).value, i);
+      return {
+        kind: "output",
+        value: parsed,
+        evidence: { verdict: parsed.verdict === "cannot_judge" ? "inconclusive" : "pass" },
+      };
+    },
+  };
+}
+
+export const judgeWithStrippedCtxManifest = MANIFEST;
+
+function buildJudgePrompt(input: Input): string {
+  const candidates = input.candidates
+    .map((c, i) => `Candidate ${i}:\n${safeStringify(c)}`)
+    .join("\n\n");
+  const keys = input.disagreement_keys?.length
+    ? `\nDisagreement keys (paths that differ): ${input.disagreement_keys.join(", ")}\n`
+    : "";
+  return `Claim under review:\n${input.claim}\n${keys}\n${candidates}\n\nReturn JSON: { verdict: "candidate_0" | "candidate_1" | "neither" | "cannot_judge", rationale: string }`;
+}
+
+function parseJudgeOutput(raw: unknown, input: Input): Output {
+  // The child llm_call returns { value, model, tokens, method }. The
+  // schema-validated `value` is whatever the judge produced.
+  const inner = (raw as { value?: unknown }).value ?? raw;
+  let parsed: Record<string, unknown>;
+  if (typeof inner === "string") {
+    try {
+      parsed = JSON.parse(inner) as Record<string, unknown>;
+    } catch {
+      return {
+        verdict: "cannot_judge",
+        rationale: `judge returned unparseable text: ${inner.slice(0, 200)}`,
+      };
+    }
+  } else if (typeof inner === "object" && inner !== null) {
+    parsed = inner as Record<string, unknown>;
+  } else {
+    return { verdict: "cannot_judge", rationale: "judge returned no structured answer" };
+  }
+
+  const v = parsed["verdict"];
+  const rationale = typeof parsed["rationale"] === "string" ? (parsed["rationale"] as string) : "";
+
+  const verdict =
+    v === "candidate_0" || v === "candidate_1" || v === "neither" || v === "cannot_judge"
+      ? v
+      : "cannot_judge";
+
+  let chosen: unknown = undefined;
+  if (verdict === "candidate_0") chosen = input.candidates[0];
+  else if (verdict === "candidate_1") chosen = input.candidates[1];
+
+  const out: Output = { verdict, rationale };
+  if (chosen !== undefined) out.chosen = chosen;
+  return out;
+}
+
+function safeStringify(v: unknown): string {
+  try {
+    return JSON.stringify(v, null, 2);
+  } catch {
+    return String(v);
+  }
+}

package/src/meta/parallel_fanout.ts

@@ -0,0 +1,142 @@
+/**
+ * `@agenteer/node-parallel-fanout` — meta-node that spawns N children
+ * of a target manifest (sub-plan 03 §12), collects their results, and
+ * applies an optional merger. Children run in parallel up to the
+ * runtime's `max_concurrent_children`.
+ *
+ * Typical shape: run the same `llm_call` N times with different prompts,
+ * or run a validator against several candidate patches and take the
+ * best-verdict one.
+ */
+
+import { z } from "zod";
+import {
+  makeManifest,
+  type Node,
+  type NodeInput,
+  type NodeManifest,
+  type NodeResult,
+} from "@agenteer/core";
+
+const MANIFEST: NodeManifest = makeManifest({
+  id: "@agenteer/node-parallel-fanout",
+  name: "parallel_fanout",
+  description:
+    "Spawn N children of a target manifest with per-child inputs; collect and optionally merge results.",
+  determinism: "stochastic",
+  // Children handle their own capabilities; the fanout itself only
+  // spawns. Runtime narrows via the parent's envelope.
+  required_actions: [],
+  dynamic_actions: true,
+  dynamic_action_spec: "spawn:${input.manifest_id}",
+  tags: ["meta"],
+});
+
+const InputSchema = z.object({
+  manifest_id: z.string().min(1),
+  /** Per-child input payload. Length decides the fan-out degree. */
+  inputs: z.array(z.unknown()).min(1),
+  /** How to consume children. `all` re-enters with every result; `any`
+   *  short-circuits on the first output; `race` bounds by a budget. */
+  join: z
+    .union([
+      z.object({ mode: z.literal("all") }),
+      z.object({ mode: z.literal("any") }),
+      z.object({
+        mode: z.literal("race_with_budget"),
+        budget_ms: z.number().int().positive(),
+        min_results: z.number().int().positive(),
+      }),
+    ])
+    .default({ mode: "all" }),
+  /** Optional merger — defaults to returning the raw array. */
+  merge: z
+    .union([
+      z.literal("concat"),
+      z.literal("first_pass"),
+      z.literal("first_output"),
+    ])
+    .default("concat"),
+  attenuate: z.array(z.string()).optional(),
+});
+
+const OutputSchema = z.object({
+  mode: z.enum(["all", "any", "race_with_budget"]),
+  /** Per-child summary: correlation + result-kind + (for output) value. */
+  children: z.array(
+    z.object({
+      correlation: z.string(),
+      kind: z.string(),
+      value: z.unknown().optional(),
+      reason: z.string().optional(),
+    }),
+  ),
+  /** Merged payload per `merge`. */
+  merged: z.unknown(),
+});
+
+type Input = z.input<typeof InputSchema>;
+type Output = z.infer<typeof OutputSchema>;
+
+export function parallelFanoutFactory(): Node<Input, Output> {
+  return {
+    manifest: MANIFEST,
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    ctx: [],
+    model: null,
+    async execute(input: NodeInput<Input>): Promise<NodeResult<Output>> {
+      const spec = input.original;
+
+      if (!input.children) {
+        // First call: fan out.
+        return {
+          kind: "spawn_children",
+          join: spec.join ?? { mode: "all" },
+          children: spec.inputs.map((childInput, i) => ({
+            manifest_id: spec.manifest_id,
+            input: childInput,
+            correlation: `fan-${i}`,
+            ...(spec.attenuate ? { attenuate: spec.attenuate } : {}),
+          })),
+        };
+      }
+
+      // Re-entry: collect + merge.
+      const children = input.children.map((c) => {
+        const base = { correlation: c.correlation, kind: c.result.kind };
+        if (c.result.kind === "output") {
+          return { ...base, value: (c.result as { value: unknown }).value };
+        }
+        if (c.result.kind === "failed") {
+          return { ...base, reason: (c.result as { reason: string }).reason };
+        }
+        return base;
+      });
+
+      const mergeMode = spec.merge ?? "concat";
+      const values: unknown[] = [];
+      for (const c of children) {
+        if (c.kind === "output" && "value" in c) values.push((c as { value: unknown }).value);
+      }
+      const merged =
+        mergeMode === "first_output"
+          ? (values[0] ?? null)
+          : mergeMode === "first_pass"
+            ? (values.find((v) => !!v) ?? null)
+            : values;
+
+      const mode = (spec.join ?? { mode: "all" }).mode;
+      return {
+        kind: "output",
+        value: { mode, children, merged },
+        evidence: {
+          verdict:
+            children.some((c) => c.kind === "output") ? "pass" : "fail",
+        },
+      };
+    },
+  };
+}
+
+export const parallelFanoutManifest = MANIFEST;