@tea-agent/loop-agent 0.39.0-beta.2 → 0.39.0-beta.4

package/dist/workflows/dag/frontend-split-orchestrator.js

@@ -0,0 +1,899 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { frontendHumanDecisionEnvelopeSchema, frontendHumanDecisionReceiptSchema } from "./frontend-human-decision.js";
+import { frontendOperationStateSchema, frontendOperationTerminalSchema, isFrontendOperationTerminalState, } from "./frontend-recovery-capsule.js";
+const idSchema = z.string().trim().min(1);
+const digestSchema = z.string().regex(/^[a-f0-9]{64}$/);
+const positiveIntegerSchema = z.number().int().positive();
+const nonnegativeIntegerSchema = z.number().int().nonnegative();
+const commitStateSchema = z.literal("committed");
+export const frontendCommittedFactRefSchema = z
+    .object({ ref: idSchema, digest: digestSchema, commitState: commitStateSchema })
+    .strict();
+function parseBoundedPath(value) {
+    if (!value || value === "." || value === "**" || value === "*" || value.startsWith("/") || value.includes("\\"))
+        return undefined;
+    const rawSegments = value.split("/");
+    if (rawSegments.some((segment) => segment.length === 0 || segment === "." || segment === ".."))
+        return undefined;
+    const trailingGlobstar = rawSegments.at(-1) === "**";
+    const segments = trailingGlobstar ? rawSegments.slice(0, -1) : rawSegments;
+    if (segments.length === 0)
+        return undefined;
+    for (const segment of segments) {
+        if (segment.includes("**"))
+            return undefined;
+        // The canonical contract intentionally supports only literal characters and
+        // `*` within one path segment. Syntax whose language cannot be decided by
+        // the matcher below is rejected rather than approximated by a prefix.
+        if (/[?\[\]{}()!+@]/.test(segment))
+            return undefined;
+    }
+    return { segments, trailingGlobstar };
+}
+function isBoundedPath(value) {
+    return parseBoundedPath(value) !== undefined;
+}
+const boundedPathSchema = z.string().refine(isBoundedPath, "path must use the supported bounded repo-relative glob grammar");
+function canonicalValue(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalValue);
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([, item]) => item !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, item]) => [key, canonicalValue(item)]));
+    }
+    return value;
+}
+export function canonicalFrontendSplitJson(value) {
+    return JSON.stringify(canonicalValue(value));
+}
+export function computeFrontendSplitDigest(value) {
+    return createHash("sha256").update(canonicalFrontendSplitJson(value), "utf8").digest("hex");
+}
+function unique(values, label) {
+    if (new Set(values).size !== values.length)
+        throw new Error(`duplicate ${label}`);
+}
+function sortStrings(values) {
+    return [...values].sort((a, b) => a.localeCompare(b));
+}
+const requirementSchema = z.object({ requirementId: idSchema, implementable: z.boolean() }).strict();
+const coverageSchema = z.object({ requirementId: idSchema, childId: idSchema, role: z.enum(["primary", "supporting"]) }).strict();
+const childSchema = z
+    .object({
+    childId: idSchema,
+    taskId: idSchema,
+    operationId: idSchema,
+    allowedPaths: z.array(boundedPathSchema).min(1),
+    writeSet: z.array(boundedPathSchema).min(1),
+    required: z.boolean(),
+})
+    .strict();
+const dependencySchema = z.object({ childId: idSchema, dependsOn: idSchema }).strict();
+const sharedSurfaceSchema = z
+    .object({
+    path: boundedPathSchema,
+    childIds: z.array(idSchema).min(2),
+    policy: z.enum(["foundation", "shared-surface"]),
+    foundationOwnerChildId: idSchema.optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.policy === "foundation" && value.foundationOwnerChildId === undefined)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["foundationOwnerChildId"], message: "foundation policy requires an owner" });
+    if (value.policy !== "foundation" && value.foundationOwnerChildId !== undefined)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["foundationOwnerChildId"], message: "only foundation policy may name an owner" });
+});
+const integrationRequirementSchema = z
+    .object({
+    required: z.boolean(),
+    operationId: idSchema.optional(),
+    allowedPaths: z.array(boundedPathSchema),
+    writeSet: z.array(boundedPathSchema),
+    verifyRefs: z.array(idSchema),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value.required && value.operationId === undefined)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["operationId"], message: "required integration needs operationId" });
+    if (!value.required && value.operationId !== undefined)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["operationId"], message: "optional integration must not register operationId" });
+});
+const manifestFields = {
+    schemaVersion: z.literal(1),
+    parentOperationId: idSchema,
+    sourceRunId: idSchema,
+    sourceDigest: digestSchema,
+    requirements: z.array(requirementSchema).min(1),
+    coverage: z.array(coverageSchema),
+    children: z.array(childSchema).min(1),
+    dependencies: z.array(dependencySchema),
+    sharedSurfaces: z.array(sharedSurfaceSchema),
+    integration: integrationRequirementSchema,
+    verifyRefs: z.array(idSchema),
+    closeoutRefs: z.array(idSchema),
+};
+export const frontendSplitManifestInputSchema = z.object(manifestFields).strict();
+const frontendSplitManifestStructuralSchema = z
+    .object({ ...manifestFields, topologicalOrder: z.array(idSchema), digest: digestSchema })
+    .strict();
+function segmentClosure(pattern, positions) {
+    const closure = new Set(positions);
+    const pending = [...closure];
+    while (pending.length > 0) {
+        const position = pending.pop();
+        if (pattern[position] === "*" && !closure.has(position + 1)) {
+            closure.add(position + 1);
+            pending.push(position + 1);
+        }
+    }
+    return [...closure].sort((a, b) => a - b);
+}
+function segmentStep(pattern, state, symbol) {
+    const next = new Set();
+    for (const position of state) {
+        const token = pattern[position];
+        if (token === "*")
+            next.add(position);
+        else if (token === symbol)
+            next.add(position + 1);
+    }
+    return segmentClosure(pattern, next);
+}
+function segmentAlphabet(left, right) {
+    const literals = new Set([...left, ...right].filter((character) => character !== "*"));
+    return [...literals].sort().concat("\0OTHER");
+}
+function segmentTransition(pattern, state, symbol) {
+    return segmentStep(pattern, state, symbol === "\0OTHER" ? "\0OTHER" : symbol);
+}
+function segmentLanguageOverlap(left, right) {
+    const alphabet = segmentAlphabet(left, right);
+    const initialLeft = segmentClosure(left, [0]);
+    const initialRight = segmentClosure(right, [0]);
+    const pending = [[initialLeft, initialRight]];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const [leftState, rightState] = pending.pop();
+        const key = `${leftState.join(",")}|${rightState.join(",")}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        if (leftState.includes(left.length) && rightState.includes(right.length))
+            return true;
+        for (const symbol of alphabet) {
+            const nextLeft = segmentTransition(left, leftState, symbol);
+            const nextRight = segmentTransition(right, rightState, symbol);
+            if (nextLeft.length > 0 && nextRight.length > 0)
+                pending.push([nextLeft, nextRight]);
+        }
+    }
+    return false;
+}
+function segmentLanguageContains(allowed, target) {
+    const alphabet = segmentAlphabet(allowed, target);
+    const initialAllowed = segmentClosure(allowed, [0]);
+    const initialTarget = segmentClosure(target, [0]);
+    const pending = [[initialAllowed, initialTarget]];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const [allowedState, targetState] = pending.pop();
+        const key = `${allowedState.join(",")}|${targetState.join(",")}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        if (targetState.includes(target.length) && !allowedState.includes(allowed.length))
+            return false;
+        for (const symbol of alphabet) {
+            const nextTarget = segmentTransition(target, targetState, symbol);
+            if (nextTarget.length === 0)
+                continue;
+            pending.push([segmentTransition(allowed, allowedState, symbol), nextTarget]);
+        }
+    }
+    return true;
+}
+function pathContains(allowedValue, targetValue) {
+    const allowed = parseBoundedPath(allowedValue);
+    const target = parseBoundedPath(targetValue);
+    if (!allowed || !target)
+        return false;
+    if (!allowed.trailingGlobstar) {
+        if (target.trailingGlobstar || allowed.segments.length !== target.segments.length)
+            return false;
+    }
+    else if (target.segments.length < allowed.segments.length) {
+        return false;
+    }
+    return allowed.segments.every((segment, index) => segmentLanguageContains(segment, target.segments[index]));
+}
+function pathsOverlap(leftValue, rightValue) {
+    const left = parseBoundedPath(leftValue);
+    const right = parseBoundedPath(rightValue);
+    if (!left || !right)
+        return false;
+    if (!left.trailingGlobstar && !right.trailingGlobstar && left.segments.length !== right.segments.length)
+        return false;
+    if (!left.trailingGlobstar && left.segments.length < right.segments.length)
+        return false;
+    if (!right.trailingGlobstar && right.segments.length < left.segments.length)
+        return false;
+    const sharedLength = Math.min(left.segments.length, right.segments.length);
+    for (let index = 0; index < sharedLength; index += 1) {
+        if (!segmentLanguageOverlap(left.segments[index], right.segments[index]))
+            return false;
+    }
+    return true;
+}
+function topo(children, dependencies) {
+    const ids = new Set(children.map((child) => child.childId));
+    const incoming = new Map([...ids].map((id) => [id, 0]));
+    const outgoing = new Map([...ids].map((id) => [id, []]));
+    for (const edge of dependencies) {
+        if (!ids.has(edge.childId) || !ids.has(edge.dependsOn))
+            throw new Error("dependency references unknown child");
+        if (edge.childId === edge.dependsOn)
+            throw new Error("self dependency");
+        incoming.set(edge.childId, (incoming.get(edge.childId) ?? 0) + 1);
+        outgoing.get(edge.dependsOn).push(edge.childId);
+    }
+    const ready = [...ids].filter((id) => incoming.get(id) === 0).sort();
+    const result = [];
+    while (ready.length > 0) {
+        const id = ready.shift();
+        result.push(id);
+        for (const dependent of outgoing.get(id).sort()) {
+            incoming.set(dependent, incoming.get(dependent) - 1);
+            if (incoming.get(dependent) === 0) {
+                ready.push(dependent);
+                ready.sort();
+            }
+        }
+    }
+    if (result.length !== children.length)
+        throw new Error("dependency cycle");
+    return result;
+}
+function reachable(from, to, dependencies) {
+    const next = new Map();
+    for (const edge of dependencies)
+        (next.get(edge.dependsOn) ?? (next.set(edge.dependsOn, []), next.get(edge.dependsOn))).push(edge.childId);
+    const pending = [from];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === to)
+            return true;
+        if (seen.has(current))
+            continue;
+        seen.add(current);
+        pending.push(...(next.get(current) ?? []));
+    }
+    return false;
+}
+function validateManifest(input) {
+    unique(input.requirements.map((item) => item.requirementId), "requirementId");
+    unique(input.children.map((item) => item.childId), "childId");
+    unique(input.children.map((item) => item.taskId), "taskId");
+    unique(input.children.map((item) => item.operationId), "operationId");
+    unique(input.dependencies.map((item) => `${item.childId}\0${item.dependsOn}`), "dependency");
+    unique(input.coverage.map((item) => `${item.requirementId}\0${item.childId}\0${item.role}`), "coverage");
+    unique(input.verifyRefs, "verifyRef");
+    unique(input.closeoutRefs, "closeoutRef");
+    unique(input.integration.allowedPaths, "integration allowedPath");
+    unique(input.integration.writeSet, "integration writeSet");
+    unique(input.integration.verifyRefs, "integration verifyRef");
+    unique(input.sharedSurfaces.map((surface) => surface.path), "shared surface path");
+    const childIds = new Set(input.children.map((item) => item.childId));
+    const requirements = new Map(input.requirements.map((item) => [item.requirementId, item]));
+    for (const item of input.coverage) {
+        if (!requirements.has(item.requirementId) || !childIds.has(item.childId))
+            throw new Error("coverage references unknown requirement or child");
+    }
+    for (const requirement of input.requirements) {
+        const primary = input.coverage.filter((item) => item.requirementId === requirement.requirementId && item.role === "primary");
+        if (requirement.implementable && primary.length !== 1)
+            throw new Error("implementable requirement must have exactly one primary owner");
+        if (!requirement.implementable && primary.length > 0)
+            throw new Error("non-implementable requirement cannot have primary owner");
+    }
+    const order = topo(input.children, input.dependencies);
+    for (const child of input.children) {
+        unique(child.allowedPaths, `allowedPath for ${child.childId}`);
+        unique(child.writeSet, `writeSet for ${child.childId}`);
+        for (const target of child.writeSet)
+            if (!child.allowedPaths.some((allowed) => pathContains(allowed, target)))
+                throw new Error(`writeSet outside allowedPaths for ${child.childId}`);
+    }
+    for (let i = 0; i < input.children.length; i += 1) {
+        for (let j = i + 1; j < input.children.length; j += 1) {
+            const left = input.children[i];
+            const right = input.children[j];
+            const overlap = left.writeSet.some((a) => right.writeSet.some((b) => pathsOverlap(a, b)));
+            if (!overlap)
+                continue;
+            const serialized = reachable(left.childId, right.childId, input.dependencies) || reachable(right.childId, left.childId, input.dependencies);
+            const foundationSerialized = input.sharedSurfaces.some((surface) => {
+                if (surface.policy !== "foundation" || !surface.foundationOwnerChildId)
+                    return false;
+                if (!surface.childIds.includes(left.childId) || !surface.childIds.includes(right.childId))
+                    return false;
+                if (!left.writeSet.some((a) => pathsOverlap(a, surface.path)) || !right.writeSet.some((b) => pathsOverlap(b, surface.path)))
+                    return false;
+                const other = surface.foundationOwnerChildId === left.childId ? right.childId : surface.foundationOwnerChildId === right.childId ? left.childId : undefined;
+                return other !== undefined && reachable(surface.foundationOwnerChildId, other, input.dependencies);
+            });
+            if (!serialized && !foundationSerialized)
+                throw new Error(`overlapping writeSet is not serialized: ${left.childId}/${right.childId}`);
+        }
+    }
+    for (const surface of input.sharedSurfaces) {
+        unique(surface.childIds, "shared surface childId");
+        if (surface.childIds.some((id) => !childIds.has(id)))
+            throw new Error("shared surface references unknown child");
+        if (surface.foundationOwnerChildId !== undefined && !surface.childIds.includes(surface.foundationOwnerChildId))
+            throw new Error("foundation owner must belong to shared surface");
+        for (const childId of surface.childIds) {
+            const child = input.children.find((item) => item.childId === childId);
+            if (!child.writeSet.some((target) => pathsOverlap(target, surface.path)))
+                throw new Error("shared surface must overlap every declared child writeSet");
+        }
+    }
+    if (input.integration.writeSet.some((target) => !input.integration.allowedPaths.some((allowed) => pathContains(allowed, target))))
+        throw new Error("integration writeSet outside allowedPaths");
+    return order;
+}
+function canonicalManifestInput(input) {
+    return {
+        ...input,
+        requirements: [...input.requirements].sort((a, b) => a.requirementId.localeCompare(b.requirementId)),
+        coverage: [...input.coverage].sort((a, b) => `${a.requirementId}\0${a.childId}\0${a.role}`.localeCompare(`${b.requirementId}\0${b.childId}\0${b.role}`)),
+        children: [...input.children].map((child) => ({ ...child, allowedPaths: sortStrings(child.allowedPaths), writeSet: sortStrings(child.writeSet) })).sort((a, b) => a.childId.localeCompare(b.childId)),
+        dependencies: [...input.dependencies].sort((a, b) => `${a.childId}\0${a.dependsOn}`.localeCompare(`${b.childId}\0${b.dependsOn}`)),
+        sharedSurfaces: [...input.sharedSurfaces].map((surface) => ({ ...surface, childIds: sortStrings(surface.childIds) })).sort((a, b) => a.path.localeCompare(b.path)),
+        integration: { ...input.integration, allowedPaths: sortStrings(input.integration.allowedPaths), writeSet: sortStrings(input.integration.writeSet), verifyRefs: sortStrings(input.integration.verifyRefs) },
+        verifyRefs: sortStrings(input.verifyRefs),
+        closeoutRefs: sortStrings(input.closeoutRefs),
+    };
+}
+export function buildFrontendSplitManifest(raw) {
+    const parsed = frontendSplitManifestInputSchema.parse(raw);
+    const canonical = canonicalManifestInput(parsed);
+    const topologicalOrder = validateManifest(canonical);
+    const withoutDigest = { ...canonical, topologicalOrder };
+    return frontendSplitManifestStructuralSchema.parse({ ...withoutDigest, digest: computeFrontendSplitDigest(withoutDigest) });
+}
+export const frontendSplitManifestSchema = frontendSplitManifestStructuralSchema.superRefine((value, ctx) => {
+    try {
+        const { digest, topologicalOrder, ...input } = value;
+        const rebuilt = buildFrontendSplitManifest(input);
+        if (canonicalFrontendSplitJson(topologicalOrder) !== canonicalFrontendSplitJson(rebuilt.topologicalOrder) || digest !== rebuilt.digest)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: "manifest canonical order or digest mismatch" });
+    }
+    catch (error) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: error instanceof Error ? error.message : "invalid manifest" });
+    }
+});
+export function parseFrontendSplitManifest(value) {
+    return frontendSplitManifestSchema.parse(value);
+}
+const operationExecutionBaseFields = {
+    operationId: idSchema,
+    operationRevision: positiveIntegerSchema,
+    sourceRunId: idSchema,
+    sourceDigest: digestSchema,
+};
+const singleTaskExecutionInputSchema = z.object({ kind: z.literal("single-task"), ...operationExecutionBaseFields }).strict();
+const splitParentExecutionInputSchema = z.object({ kind: z.literal("split-parent"), ...operationExecutionBaseFields, generation: positiveIntegerSchema, parentRecordDigest: digestSchema }).strict();
+export const frontendOperationExecutionInputSchema = z.discriminatedUnion("kind", [singleTaskExecutionInputSchema, splitParentExecutionInputSchema]);
+const singleTaskExecutionSchema = singleTaskExecutionInputSchema.extend({ digest: digestSchema }).strict();
+const splitParentExecutionSchema = splitParentExecutionInputSchema.extend({ digest: digestSchema }).strict();
+const frontendOperationExecutionStructuralSchema = z.discriminatedUnion("kind", [singleTaskExecutionSchema, splitParentExecutionSchema]);
+export const frontendOperationExecutionSchema = frontendOperationExecutionStructuralSchema.superRefine((value, ctx) => {
+    const { digest, ...payload } = value;
+    if (computeFrontendSplitDigest(payload) !== digest)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["digest"], message: "operation execution digest mismatch" });
+});
+export function buildFrontendOperationExecution(raw) {
+    const payload = frontendOperationExecutionInputSchema.parse(raw);
+    return frontendOperationExecutionStructuralSchema.parse({ ...payload, digest: computeFrontendSplitDigest(payload) });
+}
+export function parseFrontendOperationExecution(value) {
+    return frontendOperationExecutionSchema.parse(value);
+}
+export const frontendPendingBlockRefSchema = z.object({ generation: positiveIntegerSchema, childId: idSchema, operationId: idSchema, kind: z.enum(["human", "external"]), ref: idSchema, digest: digestSchema }).strict();
+export function parseFrontendPendingBlockRef(value) {
+    return frontendPendingBlockRefSchema.parse(value);
+}
+const committedOperationStateFactSchema = z.object({
+    operationId: idSchema,
+    state: frontendOperationStateSchema,
+    stateDigest: digestSchema,
+    fact: frontendCommittedFactRefSchema,
+}).strict();
+const authoritativeOperationStateFactSchema = committedOperationStateFactSchema.extend({
+    authoritativeRevision: positiveIntegerSchema,
+    authoritativeSequence: nonnegativeIntegerSchema,
+}).strict();
+const childObservationSchema = z.object({
+    childId: idSchema,
+    operationId: idSchema,
+    authoritativeRevision: positiveIntegerSchema,
+    authoritativeSequence: nonnegativeIntegerSchema,
+    state: frontendOperationStateSchema,
+    stateDigest: digestSchema,
+    observationFact: frontendCommittedFactRefSchema,
+    candidateHash: digestSchema.optional(),
+    closeoutRef: frontendCommittedFactRefSchema.optional(),
+    blockRef: frontendPendingBlockRefSchema.optional(),
+}).strict().superRefine((value, ctx) => {
+    if (value.state === "success" && (!value.candidateHash || !value.closeoutRef))
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "successful child requires candidateHash and closeoutRef" });
+    if (value.state !== "success" && (value.candidateHash || value.closeoutRef))
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "only successful child carries candidate output" });
+});
+const parentRecordFields = {
+    schemaVersion: z.literal(1), generation: positiveIntegerSchema, operationId: idSchema, operationRevision: positiveIntegerSchema,
+    sourceRunId: idSchema, sourceDigest: digestSchema, manifestDigest: digestSchema,
+    operationState: frontendOperationStateSchema, operationTerminal: frontendOperationTerminalSchema.optional(),
+    phase: z.enum(["materializing-children", "awaiting-children", "join-complete", "awaiting-integration", "integration-complete", "closed"]),
+    children: z.array(z.object({ childId: idSchema, operationId: idSchema }).strict()),
+    observations: z.array(childObservationSchema), pendingBlockRef: frontendPendingBlockRefSchema.optional(),
+};
+const parentRecordStructuralSchema = z.object({ ...parentRecordFields, digest: digestSchema }).strict();
+function parentWithoutDigest(parent) {
+    const { digest: _digest, ...rest } = parent;
+    return rest;
+}
+function buildParent(value) {
+    const normalized = { ...value, children: [...value.children].sort((a, b) => a.childId.localeCompare(b.childId)), observations: [...value.observations].sort((a, b) => a.childId.localeCompare(b.childId)) };
+    return parentRecordStructuralSchema.parse({ ...normalized, digest: computeFrontendSplitDigest(normalized) });
+}
+export const frontendSplitParentRecordSchema = parentRecordStructuralSchema.superRefine((value, ctx) => {
+    const expected = computeFrontendSplitDigest(parentWithoutDigest(value));
+    if (expected !== value.digest)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["digest"], message: "parent digest mismatch" });
+    if (isFrontendOperationTerminalState(value.operationState) ? value.operationTerminal !== value.operationState : value.operationTerminal !== undefined)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["operationTerminal"], message: "terminal/state mismatch" });
+    if (new Set(value.children.map((item) => item.childId)).size !== value.children.length || new Set(value.children.map((item) => item.operationId)).size !== value.children.length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["children"], message: "duplicate parent child binding" });
+    if (new Set(value.observations.map((item) => item.childId)).size !== value.observations.length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["observations"], message: "duplicate parent observation" });
+    if (new Set(value.observations.map((item) => `${item.observationFact.ref}\0${item.observationFact.digest}`)).size !== value.observations.length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["observations"], message: "authoritative fact identity must be unique" });
+    for (const [index, observation] of value.observations.entries()) {
+        if (!value.children.some((item) => item.childId === observation.childId && item.operationId === observation.operationId))
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["observations", index], message: "observation child binding mismatch" });
+        if (observation.blockRef && (observation.blockRef.generation !== value.generation || observation.blockRef.childId !== observation.childId || observation.blockRef.operationId !== observation.operationId || (observation.state === "blocked-human" ? observation.blockRef.kind !== "human" : observation.state === "blocked-external" ? observation.blockRef.kind !== "external" : true)))
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["observations", index, "blockRef"], message: "observation block binding mismatch" });
+        if ((observation.state === "blocked-human" || observation.state === "blocked-external") !== (observation.blockRef !== undefined))
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["observations", index, "blockRef"], message: "blocked state/ref mismatch" });
+    }
+    if (value.pendingBlockRef && (value.pendingBlockRef.generation !== value.generation || !value.observations.some((item) => item.blockRef && canonicalFrontendSplitJson(item.blockRef) === canonicalFrontendSplitJson(value.pendingBlockRef))))
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["pendingBlockRef"], message: "pending block binding mismatch" });
+    if (canonicalFrontendSplitJson(value.children) !== canonicalFrontendSplitJson([...value.children].sort((a, b) => a.childId.localeCompare(b.childId))) || canonicalFrontendSplitJson(value.observations) !== canonicalFrontendSplitJson([...value.observations].sort((a, b) => a.childId.localeCompare(b.childId))))
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "parent arrays are not canonical" });
+});
+export function parseFrontendSplitParentRecord(value) { return frontendSplitParentRecordSchema.parse(value); }
+const splitHumanEnvelopeSchema = frontendHumanDecisionEnvelopeSchema.refine((value) => value.kind === "split-materialization-approval", "human split authorization requires a split-materialization-approval envelope");
+const splitHumanReceiptSchema = frontendHumanDecisionReceiptSchema.refine((value) => value.kind === "split-materialization-approval", "human split authorization requires split-materialization-approval");
+const authorizationSchema = z.discriminatedUnion("mode", [
+    z.object({ mode: z.literal("automatic"), authorized: z.literal(true) }).strict(),
+    z.object({ mode: z.literal("human"), envelope: splitHumanEnvelopeSchema, receipt: splitHumanReceiptSchema }).strict(),
+]);
+export const initializeFrontendSplitParentInputSchema = z.object({
+    execution: frontendOperationExecutionSchema,
+    manifest: frontendSplitManifestSchema,
+    expectedOperationRevision: positiveIntegerSchema,
+    successorOperationRevision: positiveIntegerSchema.optional(),
+    envelopeTargetDigest: digestSchema,
+    activeWriterOperationId: idSchema.nullable(),
+    activeProviderOperationId: idSchema.nullable(),
+    authorization: authorizationSchema,
+}).strict();
+export function initializeFrontendSplitParent(raw) {
+    const input = initializeFrontendSplitParentInputSchema.parse(raw);
+    const execution = input.execution;
+    if (execution.kind !== "single-task")
+        throw new Error("split-parent cannot be converted or initialized again");
+    const manifest = input.manifest;
+    const rejected = (reason) => ({ outcome: "rejected", reason });
+    if (execution.operationId !== manifest.parentOperationId)
+        return rejected("operation binding mismatch");
+    if (execution.sourceRunId !== manifest.sourceRunId || execution.sourceDigest !== manifest.sourceDigest)
+        return rejected("source binding mismatch");
+    if (execution.operationRevision !== input.expectedOperationRevision)
+        return rejected("operation revision CAS mismatch");
+    const successorOperationRevision = input.successorOperationRevision ?? execution.operationRevision + 1;
+    if (successorOperationRevision <= execution.operationRevision)
+        return rejected("successor operation revision must advance");
+    if (input.envelopeTargetDigest !== manifest.digest)
+        return rejected("envelope target digest mismatch");
+    if (input.activeWriterOperationId !== null || input.activeProviderOperationId !== null)
+        return rejected("active writer/provider exists");
+    if (input.authorization.mode === "human") {
+        const { envelope, receipt } = input.authorization;
+        if (envelope.kind !== "split-materialization-approval" || envelope.resumeAction !== "materialize-split" || envelope.operationId !== execution.operationId || envelope.runId !== execution.sourceRunId || envelope.operationRevision !== execution.operationRevision || envelope.targetDigest !== manifest.digest || envelope.payload.splitManifestRef.digest !== manifest.digest)
+            return rejected("split envelope binding mismatch");
+        if (receipt.kind !== "split-materialization-approval" || receipt.resumeAction !== "materialize-split" || receipt.commitState !== "committed" || receipt.consumeState !== "unconsumed")
+            return rejected("invalid split receipt state");
+        if (receipt.envelopeDigest !== envelope.digest || receipt.operationId !== execution.operationId || receipt.runId !== execution.sourceRunId || receipt.operationRevision !== execution.operationRevision || receipt.targetDigest !== manifest.digest)
+            return rejected("split receipt binding mismatch");
+        if (receipt.resolution.splitManifestRef.ref !== envelope.payload.splitManifestRef.ref || receipt.resolution.splitManifestRef.digest !== manifest.digest)
+            return rejected("split receipt manifest mismatch");
+    }
+    const parent = buildParent({ schemaVersion: 1, generation: 1, operationId: execution.operationId, operationRevision: successorOperationRevision, sourceRunId: execution.sourceRunId, sourceDigest: execution.sourceDigest, manifestDigest: manifest.digest, operationState: "orchestrating-split", phase: "materializing-children", children: manifest.children.map(({ childId, operationId }) => ({ childId, operationId })), observations: [] });
+    return { outcome: "applied", parent, execution: buildFrontendOperationExecution({ kind: "split-parent", operationId: execution.operationId, operationRevision: parent.operationRevision, sourceRunId: execution.sourceRunId, sourceDigest: execution.sourceDigest, generation: 1, parentRecordDigest: parent.digest }) };
+}
+export const frontendSplitChildObservationSchema = z.object({
+    observedGeneration: nonnegativeIntegerSchema,
+    childId: idSchema,
+    operationId: idSchema,
+    authoritativeRevision: positiveIntegerSchema,
+    authoritativeSequence: nonnegativeIntegerSchema,
+    state: frontendOperationStateSchema,
+    stateDigest: digestSchema,
+    stateFact: authoritativeOperationStateFactSchema,
+    envelopeRef: frontendCommittedFactRefSchema.optional(),
+    externalActionRef: frontendCommittedFactRefSchema.optional(),
+    candidateHash: digestSchema.optional(),
+    closeoutRef: frontendCommittedFactRefSchema.optional(),
+}).strict().superRefine((value, ctx) => {
+    if (value.state === "blocked-human" && !value.envelopeRef)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["envelopeRef"], message: "blocked-human requires envelopeRef" });
+    if (value.state !== "blocked-human" && value.envelopeRef)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["envelopeRef"], message: "only blocked-human may carry envelopeRef" });
+    if (value.state === "blocked-external" && !value.externalActionRef)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["externalActionRef"], message: "blocked-external requires externalActionRef" });
+    if (value.state !== "blocked-external" && value.externalActionRef)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["externalActionRef"], message: "only blocked-external may carry externalActionRef" });
+    if (value.state === "success" && (!value.candidateHash || !value.closeoutRef))
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "successful child requires candidateHash and closeoutRef" });
+    if (value.state !== "success" && (value.candidateHash || value.closeoutRef))
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "only successful child carries candidate output" });
+});
+const frontendSplitStaleAuditFactStructuralSchema = z.object({
+    kind: z.literal("frontend-split-stale-observation"),
+    reason: idSchema,
+    parentDigest: digestSchema,
+    observedGeneration: nonnegativeIntegerSchema,
+    childId: idSchema,
+    operationId: idSchema,
+    authoritativeRevision: positiveIntegerSchema,
+    authoritativeSequence: nonnegativeIntegerSchema,
+    authoritativeFactRef: idSchema,
+    authoritativeFactDigest: digestSchema,
+    digest: digestSchema,
+}).strict();
+export const frontendSplitStaleAuditFactSchema = frontendSplitStaleAuditFactStructuralSchema.superRefine((value, ctx) => {
+    const { digest, ...payload } = value;
+    if (computeFrontendSplitDigest(payload) !== digest)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["digest"], message: "stale audit digest mismatch" });
+});
+export function parseFrontendSplitStaleAuditFact(value) {
+    return frontendSplitStaleAuditFactSchema.parse(value);
+}
+function stale(parent, observation, reason) {
+    const payload = { kind: "frontend-split-stale-observation", reason, parentDigest: parent.digest, observedGeneration: observation.observedGeneration, childId: observation.childId, operationId: observation.operationId, authoritativeRevision: observation.authoritativeRevision, authoritativeSequence: observation.authoritativeSequence, authoritativeFactRef: observation.stateFact.fact.ref, authoritativeFactDigest: observation.stateFact.fact.digest };
+    return { outcome: "ignored-stale", parent, auditFact: { ...payload, digest: computeFrontendSplitDigest(payload) } };
+}
+function selectedBlock(observations, manifest) {
+    const rank = new Map(manifest.topologicalOrder.map((id, index) => [id, index]));
+    return observations.filter((item) => item.blockRef).sort((a, b) => (rank.get(a.childId) - rank.get(b.childId)) || a.operationId.localeCompare(b.operationId))[0]?.blockRef;
+}
+const terminalPriority = ["failed-internal", "non-converging", "cancelled", "superseded"];
+export function observeFrontendSplitChild(parentValue, manifestValue, rawValue) {
+    const parent = parseFrontendSplitParentRecord(parentValue);
+    const manifest = parseFrontendSplitManifest(manifestValue);
+    const raw = frontendSplitChildObservationSchema.parse(rawValue);
+    if (parent.operationTerminal !== undefined)
+        return stale(parent, raw, "parent is terminal");
+    if (parent.phase !== "materializing-children" && parent.phase !== "awaiting-children")
+        return stale(parent, raw, "parent child observations are frozen");
+    if (raw.observedGeneration !== parent.generation)
+        return stale(parent, raw, "generation mismatch");
+    if (parent.manifestDigest !== manifest.digest || parent.sourceDigest !== manifest.sourceDigest || parent.sourceRunId !== manifest.sourceRunId)
+        return stale(parent, raw, "parent binding drift");
+    const registered = parent.children.find((item) => item.childId === raw.childId);
+    if (!registered || registered.operationId !== raw.operationId)
+        return stale(parent, raw, "unknown child or operation mismatch");
+    const stateFact = authoritativeOperationStateFactSchema.safeParse(raw.stateFact);
+    if (!digestSchema.safeParse(raw.stateDigest).success || !stateFact.success)
+        return stale(parent, raw, "invalid state digest or state fact");
+    if (stateFact.data.operationId !== raw.operationId || stateFact.data.state !== raw.state || stateFact.data.stateDigest !== raw.stateDigest)
+        return stale(parent, raw, "authoritative child state fact mismatch");
+    if (stateFact.data.authoritativeRevision !== raw.authoritativeRevision || stateFact.data.authoritativeSequence !== raw.authoritativeSequence)
+        return stale(parent, raw, "authoritative fact position mismatch");
+    let blockRef;
+    if (raw.state === "blocked-human") {
+        const ref = frontendCommittedFactRefSchema.parse(raw.envelopeRef);
+        blockRef = { generation: parent.generation, childId: raw.childId, operationId: raw.operationId, kind: "human", ref: ref.ref, digest: ref.digest };
+    }
+    else if (raw.state === "blocked-external") {
+        const ref = frontendCommittedFactRefSchema.parse(raw.externalActionRef);
+        blockRef = { generation: parent.generation, childId: raw.childId, operationId: raw.operationId, kind: "external", ref: ref.ref, digest: ref.digest };
+    }
+    const observation = childObservationSchema.parse({ childId: raw.childId, operationId: raw.operationId, authoritativeRevision: stateFact.data.authoritativeRevision, authoritativeSequence: stateFact.data.authoritativeSequence, state: raw.state, stateDigest: raw.stateDigest, observationFact: stateFact.data.fact, candidateHash: raw.candidateHash, closeoutRef: raw.closeoutRef, blockRef });
+    const existing = parent.observations.find((item) => item.childId === raw.childId);
+    if (existing && canonicalFrontendSplitJson(existing) === canonicalFrontendSplitJson(observation))
+        return stale(parent, raw, "authoritative fact replay");
+    if (parent.observations.some((item) => item.observationFact.ref === observation.observationFact.ref && item.observationFact.digest === observation.observationFact.digest))
+        return stale(parent, raw, "authoritative fact identity reused");
+    if (existing) {
+        const older = raw.authoritativeRevision < existing.authoritativeRevision || (raw.authoritativeRevision === existing.authoritativeRevision && raw.authoritativeSequence < existing.authoritativeSequence);
+        const samePosition = raw.authoritativeRevision === existing.authoritativeRevision && raw.authoritativeSequence === existing.authoritativeSequence;
+        if (older || samePosition)
+            return stale(parent, raw, samePosition ? "conflicting authoritative fact position" : "older authoritative fact");
+        if (isFrontendOperationTerminalState(existing.state))
+            return stale(parent, raw, "terminal child observation is irreversible");
+    }
+    const observations = [...parent.observations.filter((item) => item.childId !== raw.childId), observation];
+    const terminal = terminalPriority.find((state) => observations.some((item) => item.state === state));
+    const pendingBlockRef = selectedBlock(observations, manifest);
+    const operationState = terminal ?? (pendingBlockRef?.kind === "human" ? "blocked-human" : pendingBlockRef ? "blocked-external" : "orchestrating-split");
+    const next = buildParent({ ...parentWithoutDigest(parent), operationRevision: parent.operationRevision + 1, observations, pendingBlockRef, operationState, operationTerminal: terminal, phase: parent.phase === "materializing-children" ? "awaiting-children" : parent.phase });
+    return { outcome: "applied", parent: next };
+}
+const candidateItemSchema = z.object({ childId: idSchema, operationId: idSchema, topologyRank: positiveIntegerSchema, generation: positiveIntegerSchema, candidateHash: digestSchema, closeoutRef: frontendCommittedFactRefSchema, stateDigest: digestSchema }).strict();
+const candidateBindingStructuralSchema = z.object({ schemaVersion: z.literal(1), generation: positiveIntegerSchema, sourceDigest: digestSchema, manifestDigest: digestSchema, parentDigest: digestSchema, children: z.array(candidateItemSchema), digest: digestSchema }).strict();
+export const frontendSplitCandidateBindingSchema = candidateBindingStructuralSchema.superRefine((value, ctx) => {
+    const { digest, ...payload } = value;
+    if (computeFrontendSplitDigest(payload) !== digest)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["digest"], message: "candidate binding digest mismatch" });
+    if (new Set(value.children.map((item) => item.childId)).size !== value.children.length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["children"], message: "duplicate candidate child" });
+    if (new Set(value.children.map((item) => item.operationId)).size !== value.children.length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["children"], message: "duplicate candidate operation" });
+    for (const [index, child] of value.children.entries()) {
+        if (child.generation !== value.generation)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["children", index, "generation"], message: "candidate child generation mismatch" });
+        if (child.topologyRank !== index + 1)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["children", index, "topologyRank"], message: "candidate topology ranks must be contiguous from one" });
+    }
+});
+export function parseFrontendSplitCandidateBinding(value) {
+    return frontendSplitCandidateBindingSchema.parse(value);
+}
+export function frontendSplitDependencyClosure(manifestValue, childId) {
+    const manifest = parseFrontendSplitManifest(manifestValue);
+    if (!manifest.children.some((child) => child.childId === childId))
+        throw new Error(`unknown child: ${childId}`);
+    const dependencies = new Map();
+    for (const edge of manifest.dependencies) {
+        const prerequisites = dependencies.get(edge.childId) ?? [];
+        prerequisites.push(edge.dependsOn);
+        dependencies.set(edge.childId, prerequisites);
+    }
+    const closure = new Set();
+    const pending = [...(dependencies.get(childId) ?? [])];
+    while (pending.length > 0) {
+        const prerequisiteId = pending.pop();
+        if (closure.has(prerequisiteId))
+            continue;
+        closure.add(prerequisiteId);
+        pending.push(...(dependencies.get(prerequisiteId) ?? []));
+    }
+    return manifest.topologicalOrder.filter((id) => closure.has(id));
+}
+export function isFrontendSplitChildReady(parentValue, manifestValue, childId) {
+    const parent = parseFrontendSplitParentRecord(parentValue);
+    const manifest = parseFrontendSplitManifest(manifestValue);
+    if (parent.operationTerminal !== undefined || parent.operationState !== "orchestrating-split" || parent.generation < 1 || parent.manifestDigest !== manifest.digest || parent.sourceDigest !== manifest.sourceDigest)
+        return false;
+    return frontendSplitDependencyClosure(manifest, childId).every((dependencyId) => {
+        const child = manifest.children.find((item) => item.childId === dependencyId);
+        const observation = parent.observations.find((item) => item.childId === dependencyId);
+        return observation?.operationId === child.operationId && observation.state === "success" && observation.observationFact.commitState === "committed" && observation.closeoutRef?.commitState === "committed" && observation.candidateHash !== undefined;
+    });
+}
+function requiredDependencyClosure(manifest) {
+    const dependencies = new Map();
+    for (const edge of manifest.dependencies) {
+        const prerequisites = dependencies.get(edge.childId) ?? [];
+        prerequisites.push(edge.dependsOn);
+        dependencies.set(edge.childId, prerequisites);
+    }
+    const closure = new Set(manifest.children.filter((child) => child.required).map((child) => child.childId));
+    const pending = [...closure];
+    while (pending.length > 0) {
+        const childId = pending.pop();
+        for (const prerequisiteId of dependencies.get(childId) ?? []) {
+            if (closure.has(prerequisiteId))
+                continue;
+            closure.add(prerequisiteId);
+            pending.push(prerequisiteId);
+        }
+    }
+    return closure;
+}
+function candidateMatchesParent(candidate, parent, manifest) {
+    const closure = requiredDependencyClosure(manifest);
+    const required = manifest.topologicalOrder
+        .filter((childId) => closure.has(childId))
+        .map((childId) => manifest.children.find((child) => child.childId === childId));
+    if (candidate.children.length !== required.length)
+        return false;
+    return required.every((child, index) => {
+        const item = candidate.children[index];
+        const observation = parent.observations.find((observed) => observed.childId === child.childId);
+        return item !== undefined && item.childId === child.childId && item.operationId === child.operationId && item.topologyRank === index + 1 && item.generation === parent.generation && observation !== undefined && observation.operationId === child.operationId && observation.state === "success" && item.stateDigest === observation.stateDigest && item.candidateHash === observation.candidateHash && item.closeoutRef.ref === observation.closeoutRef?.ref && item.closeoutRef.digest === observation.closeoutRef.digest;
+    });
+}
+export function prepareFrontendSplitJoin(parentValue, manifestValue) {
+    const parent = parseFrontendSplitParentRecord(parentValue);
+    const manifest = parseFrontendSplitManifest(manifestValue);
+    if (parent.generation < 1 || parent.sourceDigest !== manifest.sourceDigest || parent.manifestDigest !== manifest.digest || parent.operationState !== "orchestrating-split" || parent.operationTerminal !== undefined || parent.pendingBlockRef !== undefined || (parent.phase !== "materializing-children" && parent.phase !== "awaiting-children"))
+        return { outcome: "not-ready", reason: "stale or non-runnable parent binding" };
+    const closure = requiredDependencyClosure(manifest);
+    for (const childId of manifest.topologicalOrder) {
+        if (!closure.has(childId))
+            continue;
+        const child = manifest.children.find((item) => item.childId === childId);
+        const observation = parent.observations.find((item) => item.childId === childId);
+        if (!observation || observation.operationId !== child.operationId || observation.state !== "success" || !observation.candidateHash || !observation.closeoutRef || observation.observationFact.commitState !== "committed" || observation.closeoutRef.commitState !== "committed") {
+            return { outcome: "not-ready", reason: `${child.required ? "required" : "dependency"} child ${childId} is incomplete` };
+        }
+    }
+    const children = [];
+    for (const childId of manifest.topologicalOrder) {
+        if (!closure.has(childId))
+            continue;
+        const child = manifest.children.find((item) => item.childId === childId);
+        const observation = parent.observations.find((item) => item.childId === childId);
+        children.push({ childId, operationId: child.operationId, topologyRank: children.length + 1, generation: parent.generation, candidateHash: observation.candidateHash, closeoutRef: observation.closeoutRef, stateDigest: observation.stateDigest });
+    }
+    const nextParent = buildParent({ ...parentWithoutDigest(parent), operationRevision: parent.operationRevision + 1, phase: manifest.integration.required ? "awaiting-integration" : "join-complete" });
+    const payload = { schemaVersion: 1, generation: parent.generation, sourceDigest: parent.sourceDigest, manifestDigest: manifest.digest, parentDigest: nextParent.digest, children };
+    return { outcome: "ready", parent: nextParent, binding: candidateBindingStructuralSchema.parse({ ...payload, digest: computeFrontendSplitDigest(payload) }) };
+}
+const integrationBindingStructuralSchema = z.object({ schemaVersion: z.literal(1), generation: positiveIntegerSchema, sourceDigest: digestSchema, manifestDigest: digestSchema, candidateBindingsDigest: digestSchema, parentDigest: digestSchema, operationId: idSchema, state: z.literal("success"), stateDigest: digestSchema, observationFact: frontendCommittedFactRefSchema, closeoutRef: frontendCommittedFactRefSchema, digest: digestSchema }).strict();
+export const frontendSplitIntegrationBindingSchema = integrationBindingStructuralSchema.superRefine((value, ctx) => { const { digest, ...payload } = value; if (computeFrontendSplitDigest(payload) !== digest)
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: "integration binding digest mismatch" }); });
+export function parseFrontendSplitIntegrationBinding(value) {
+    return frontendSplitIntegrationBindingSchema.parse(value);
+}
+export const completeFrontendSplitIntegrationInputSchema = z.object({
+    observedGeneration: nonnegativeIntegerSchema,
+    operationId: idSchema,
+    state: frontendOperationStateSchema,
+    stateDigest: digestSchema,
+    candidateBindingsDigest: digestSchema,
+    stateFact: committedOperationStateFactSchema,
+    closeoutRef: frontendCommittedFactRefSchema,
+}).strict();
+export function completeFrontendSplitIntegration(parentValue, manifestValue, candidateValue, rawInput) {
+    const input = completeFrontendSplitIntegrationInputSchema.parse(rawInput);
+    const parent = parseFrontendSplitParentRecord(parentValue);
+    const manifest = parseFrontendSplitManifest(manifestValue);
+    const candidate = frontendSplitCandidateBindingSchema.parse(candidateValue);
+    if (!manifest.integration.required || !manifest.integration.operationId)
+        return { outcome: "ignored-stale", reason: "integration is not required" };
+    if (input.observedGeneration !== parent.generation || candidate.generation !== parent.generation || parent.manifestDigest !== manifest.digest || candidate.manifestDigest !== manifest.digest || candidate.sourceDigest !== parent.sourceDigest || candidate.parentDigest !== parent.digest || !candidateMatchesParent(candidate, parent, manifest) || parent.phase !== "awaiting-integration" || parent.operationState !== "orchestrating-split" || input.candidateBindingsDigest !== candidate.digest || input.operationId !== manifest.integration.operationId)
+        return { outcome: "ignored-stale", reason: "integration freshness mismatch" };
+    const stateFact = committedOperationStateFactSchema.safeParse(input.stateFact);
+    if (input.state !== "success" || !stateFact.success || stateFact.data.operationId !== input.operationId || stateFact.data.state !== "success" || stateFact.data.stateDigest !== input.stateDigest || !frontendCommittedFactRefSchema.safeParse(input.closeoutRef).success || !digestSchema.safeParse(input.stateDigest).success)
+        return { outcome: "ignored-stale", reason: "integration did not commit authoritative success" };
+    const nextParent = buildParent({ ...parentWithoutDigest(parent), operationRevision: parent.operationRevision + 1, phase: "integration-complete" });
+    const payload = { schemaVersion: 1, generation: parent.generation, sourceDigest: parent.sourceDigest, manifestDigest: manifest.digest, candidateBindingsDigest: candidate.digest, parentDigest: nextParent.digest, operationId: input.operationId, state: "success", stateDigest: input.stateDigest, observationFact: stateFact.data.fact, closeoutRef: input.closeoutRef };
+    return { outcome: "accepted", parent: nextParent, binding: integrationBindingStructuralSchema.parse({ ...payload, digest: computeFrontendSplitDigest(payload) }) };
+}
+export const frontendSplitChildCloseoutFactsSchema = z.object({ childId: idSchema, residualRisks: z.array(z.string().min(1)), frontendTestHandoffRef: idSchema.optional() }).strict();
+const aggregateStructuralSchema = z.object({ schemaVersion: z.literal(1), generation: positiveIntegerSchema, parentOperationId: idSchema, sourceRunId: idSchema, sourceDigest: digestSchema, manifestDigest: digestSchema, candidateBindingsDigest: digestSchema, childCloseouts: z.array(z.object({ childId: idSchema, operationId: idSchema, topologyRank: positiveIntegerSchema, closeoutRef: frontendCommittedFactRefSchema }).strict()), frontendTestHandoffRefs: z.array(idSchema), remainingRisks: z.array(z.string().min(1)), integrationBindingDigest: digestSchema.optional(), integrationCloseoutRef: frontendCommittedFactRefSchema.optional(), operationTerminal: z.literal("success"), digest: digestSchema }).strict();
+export const frontendSplitAggregateCloseoutSchema = aggregateStructuralSchema.superRefine((value, ctx) => {
+    const { digest, ...payload } = value;
+    if (computeFrontendSplitDigest(payload) !== digest)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["digest"], message: "aggregate digest mismatch" });
+    if ((value.integrationBindingDigest === undefined) !== (value.integrationCloseoutRef === undefined))
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "integration binding and closeout must be present together" });
+    if (new Set(value.childCloseouts.map((item) => item.childId)).size !== value.childCloseouts.length || new Set(value.childCloseouts.map((item) => item.operationId)).size !== value.childCloseouts.length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["childCloseouts"], message: "duplicate aggregate child binding" });
+    if (value.childCloseouts.some((item, index) => item.topologyRank !== index + 1))
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["childCloseouts"], message: "aggregate child closeout ranks must be contiguous from one" });
+    if (new Set(value.frontendTestHandoffRefs).size !== value.frontendTestHandoffRefs.length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["frontendTestHandoffRefs"], message: "duplicate aggregate frontend-test handoff ref" });
+});
+export function buildFrontendSplitAggregateCloseout(parentValue, manifestValue, candidateValue, integrationValue, childCloseoutFacts = []) {
+    const parent = parseFrontendSplitParentRecord(parentValue);
+    const manifest = parseFrontendSplitManifest(manifestValue);
+    const candidate = frontendSplitCandidateBindingSchema.parse(candidateValue);
+    if (candidate.generation !== parent.generation || candidate.sourceDigest !== parent.sourceDigest || candidate.manifestDigest !== manifest.digest || parent.manifestDigest !== manifest.digest || parent.operationState !== "orchestrating-split" || parent.operationTerminal !== undefined || parent.pendingBlockRef !== undefined)
+        throw new Error("aggregate freshness mismatch");
+    if (!candidateMatchesParent(candidate, parent, manifest))
+        throw new Error("aggregate child binding mismatch");
+    let integration;
+    if (manifest.integration.required) {
+        integration = frontendSplitIntegrationBindingSchema.parse(integrationValue);
+        if (parent.phase !== "integration-complete" || integration.generation !== parent.generation || integration.sourceDigest !== parent.sourceDigest || integration.manifestDigest !== manifest.digest || integration.candidateBindingsDigest !== candidate.digest || integration.operationId !== manifest.integration.operationId || integration.state !== "success" || integration.parentDigest !== parent.digest)
+            throw new Error("aggregate integration freshness mismatch");
+    }
+    else {
+        if (parent.phase !== "join-complete" || candidate.parentDigest !== parent.digest)
+            throw new Error("aggregate join freshness mismatch");
+        if (integrationValue !== undefined)
+            throw new Error("unexpected integration binding");
+    }
+    const childCloseouts = candidate.children.map((item) => ({ childId: item.childId, operationId: item.operationId, topologyRank: item.topologyRank, closeoutRef: item.closeoutRef }));
+    const facts = childCloseoutFacts.map((item) => frontendSplitChildCloseoutFactsSchema.parse(item));
+    if (facts.length > 0 && (facts.length !== candidate.children.length || facts.some((item, index) => item.childId !== candidate.children[index]?.childId)))
+        throw new Error("aggregate child closeout facts childId mismatch");
+    const frontendTestHandoffRefs = facts.flatMap((item) => (item.frontendTestHandoffRef === undefined ? [] : [item.frontendTestHandoffRef]));
+    const remainingRisks = facts.flatMap((item) => item.residualRisks);
+    const payload = { schemaVersion: 1, generation: parent.generation, parentOperationId: parent.operationId, sourceRunId: parent.sourceRunId, sourceDigest: parent.sourceDigest, manifestDigest: manifest.digest, candidateBindingsDigest: candidate.digest, childCloseouts, frontendTestHandoffRefs, remainingRisks, integrationBindingDigest: integration?.digest, integrationCloseoutRef: integration?.closeoutRef, operationTerminal: "success" };
+    return aggregateStructuralSchema.parse({ ...payload, digest: computeFrontendSplitDigest(payload) });
+}
+export function parseFrontendSplitAggregateCloseout(value) { return frontendSplitAggregateCloseoutSchema.parse(value); }
+function rebuildFrontendSplitParent(parent, patch) {
+    const nextParent = buildParent({ ...parentWithoutDigest(parent), ...patch, operationRevision: parent.operationRevision + 1 });
+    return {
+        parent: nextParent,
+        execution: buildFrontendOperationExecution({ kind: "split-parent", operationId: nextParent.operationId, operationRevision: nextParent.operationRevision, sourceRunId: nextParent.sourceRunId, sourceDigest: nextParent.sourceDigest, generation: nextParent.generation, parentRecordDigest: nextParent.digest }),
+    };
+}
+export function advanceFrontendSplitParent(parentValue, patch) {
+    const parent = parseFrontendSplitParentRecord(parentValue);
+    if (patch.phase === "closed" || patch.operationState === "success" || patch.operationTerminal === "success")
+        throw new Error("aggregate finalization is the only success transition");
+    return rebuildFrontendSplitParent(parent, patch);
+}
+export function finalizeFrontendSplitAggregate(parentValue, aggregateValue, committedRefValue) {
+    const parent = parseFrontendSplitParentRecord(parentValue);
+    const aggregate = frontendSplitAggregateCloseoutSchema.parse(aggregateValue);
+    const committedRef = frontendCommittedFactRefSchema.parse(committedRefValue);
+    if (committedRef.digest !== aggregate.digest)
+        throw new Error("committed aggregate ref digest mismatch");
+    if (aggregate.parentOperationId !== parent.operationId || aggregate.generation !== parent.generation || aggregate.sourceRunId !== parent.sourceRunId || aggregate.sourceDigest !== parent.sourceDigest || aggregate.manifestDigest !== parent.manifestDigest || aggregate.operationTerminal !== "success")
+        throw new Error("aggregate finalization freshness mismatch");
+    if (parent.operationTerminal !== undefined || (parent.phase !== "join-complete" && parent.phase !== "integration-complete"))
+        throw new Error("parent is not ready for aggregate finalization");
+    return rebuildFrontendSplitParent(parent, { phase: "closed", operationState: "success", operationTerminal: "success", pendingBlockRef: undefined });
+}
+export function assertFrontendSplitBindingConsistency(input) {
+    const { parent, manifest, candidateBinding: candidate, integrationBinding: integration, aggregateCloseout } = input;
+    const early = parent.phase === "materializing-children" || parent.phase === "awaiting-children";
+    if (early && (candidate || integration || aggregateCloseout))
+        throw new Error("early split projection may not carry join bindings");
+    if (parent.phase !== "closed" && aggregateCloseout)
+        throw new Error("only closed success may carry aggregate closeout");
+    if (parent.phase === "closed") {
+        if (parent.operationState !== "success" || parent.operationTerminal !== "success" || !candidate || !aggregateCloseout)
+            throw new Error("closed split projection requires committed aggregate success");
+    }
+    else if (parent.operationState === "success" || parent.operationTerminal === "success")
+        throw new Error("split success requires closed aggregate projection");
+    if (!candidate) {
+        if (integration)
+            throw new Error("integration binding requires candidate binding");
+        if (!early && parent.phase !== "closed")
+            throw new Error("join phase requires candidate binding");
+        return;
+    }
+    if (candidate.generation !== parent.generation || candidate.sourceDigest !== parent.sourceDigest || candidate.manifestDigest !== manifest.digest || !candidateMatchesParent(candidate, parent, manifest))
+        throw new Error("candidate projection freshness mismatch");
+    if ((parent.phase === "awaiting-integration" || parent.phase === "join-complete") && candidate.parentDigest !== parent.digest)
+        throw new Error("candidate parent digest mismatch");
+    if (manifest.integration.required) {
+        if ((parent.phase === "integration-complete" || parent.phase === "closed") && !integration)
+            throw new Error("integration projection is missing");
+        if (parent.phase === "awaiting-integration" && integration)
+            throw new Error("integration completed before callback");
+    }
+    else if (integration)
+        throw new Error("unexpected integration projection");
+    if (integration && (integration.generation !== parent.generation || integration.sourceDigest !== parent.sourceDigest || integration.manifestDigest !== manifest.digest || integration.candidateBindingsDigest !== candidate.digest || integration.operationId !== manifest.integration.operationId || (parent.phase === "integration-complete" && integration.parentDigest !== parent.digest)))
+        throw new Error("integration projection freshness mismatch");
+    if (!aggregateCloseout)
+        return;
+    const aggregate = aggregateCloseout.value;
+    if (aggregateCloseout.committedRef.digest !== aggregate.digest || aggregate.parentOperationId !== parent.operationId || aggregate.generation !== parent.generation || aggregate.sourceRunId !== parent.sourceRunId || aggregate.sourceDigest !== parent.sourceDigest || aggregate.manifestDigest !== manifest.digest || aggregate.candidateBindingsDigest !== candidate.digest)
+        throw new Error("aggregate projection freshness mismatch");
+    if (aggregate.childCloseouts.length !== candidate.children.length || aggregate.childCloseouts.some((item, index) => item.childId !== candidate.children[index]?.childId || item.operationId !== candidate.children[index]?.operationId || item.topologyRank !== candidate.children[index]?.topologyRank || item.closeoutRef.ref !== candidate.children[index]?.closeoutRef.ref || item.closeoutRef.digest !== candidate.children[index]?.closeoutRef.digest))
+        throw new Error("aggregate child projection mismatch");
+    if (manifest.integration.required) {
+        if (!integration || aggregate.integrationBindingDigest !== integration.digest || aggregate.integrationCloseoutRef?.ref !== integration.closeoutRef.ref || aggregate.integrationCloseoutRef?.digest !== integration.closeoutRef.digest)
+            throw new Error("aggregate integration projection mismatch");
+    }
+    else if (aggregate.integrationBindingDigest !== undefined || aggregate.integrationCloseoutRef !== undefined)
+        throw new Error("unexpected aggregate integration projection");
+}