@tea-agent/loop-agent 0.42.0-next.1 → 0.42.0-next.11

package/dist/workflows/dag/frontend-split-application-service.js

@@ -0,0 +1,203 @@
+import { z } from "zod";
+import { assertFrontendSplitBindingConsistency, buildFrontendOperationExecution, buildFrontendSplitAggregateCloseout, completeFrontendSplitIntegration, completeFrontendSplitIntegrationInputSchema, finalizeFrontendSplitAggregate, frontendCommittedFactRefSchema, frontendOperationExecutionSchema, frontendSplitAggregateCloseoutSchema, frontendSplitCandidateBindingSchema, frontendSplitChildObservationSchema, frontendSplitIntegrationBindingSchema, frontendSplitManifestSchema, frontendSplitParentRecordSchema, isFrontendSplitChildReady, observeFrontendSplitChild, prepareFrontendSplitJoin, } from "./frontend-split-orchestrator.js";
+const idSchema = z.string().trim().min(1);
+const digestSchema = z.string().regex(/^[a-f0-9]{64}$/);
+const positiveIntegerSchema = z.number().int().positive();
+export const frontendSplitProjectionSchema = z.object({
+    revision: positiveIntegerSchema,
+    execution: frontendOperationExecutionSchema,
+    manifest: frontendSplitManifestSchema,
+    parent: frontendSplitParentRecordSchema,
+    candidateBinding: frontendSplitCandidateBindingSchema.optional(),
+    integrationBinding: frontendSplitIntegrationBindingSchema.optional(),
+    aggregateCloseout: z.object({ value: frontendSplitAggregateCloseoutSchema, committedRef: frontendCommittedFactRefSchema }).strict().optional(),
+}).strict().superRefine((value, ctx) => {
+    if (value.revision !== value.parent.operationRevision || value.execution.kind !== "split-parent" || value.execution.operationId !== value.parent.operationId || value.execution.operationRevision !== value.parent.operationRevision || value.execution.parentRecordDigest !== value.parent.digest)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "revision/execution/parent projection mismatch" });
+    if (value.manifest.parentOperationId !== value.parent.operationId || value.manifest.digest !== value.parent.manifestDigest)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "manifest/parent projection mismatch" });
+    try {
+        assertFrontendSplitBindingConsistency(value);
+    }
+    catch (error) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: error instanceof Error ? error.message : "split projection binding mismatch" });
+    }
+});
+export function assertFrontendSplitProjectionSuccessor(currentValue, nextValue) {
+    const current = frontendSplitProjectionSchema.parse(currentValue);
+    const next = frontendSplitProjectionSchema.parse(nextValue);
+    if (next.revision !== current.revision + 1 || next.parent.operationRevision !== current.parent.operationRevision + 1)
+        throw new Error("split successor revision mismatch");
+    if (JSON.stringify(next.manifest) !== JSON.stringify(current.manifest) || next.parent.operationId !== current.parent.operationId || next.parent.generation !== current.parent.generation || next.parent.sourceRunId !== current.parent.sourceRunId || next.parent.sourceDigest !== current.parent.sourceDigest || next.parent.manifestDigest !== current.parent.manifestDigest)
+        throw new Error("split successor immutable binding mismatch");
+    if (next.parent.operationState === "success" || next.parent.operationTerminal === "success" || next.parent.phase === "closed") {
+        if (!next.aggregateCloseout)
+            throw new Error("split success requires committed aggregate closeout");
+        const finalized = finalizeFrontendSplitAggregate(current.parent, next.aggregateCloseout.value, next.aggregateCloseout.committedRef);
+        const expected = frontendSplitProjectionSchema.parse({ ...current, revision: current.revision + 1, parent: finalized.parent, execution: finalized.execution, aggregateCloseout: next.aggregateCloseout });
+        if (JSON.stringify(next) !== JSON.stringify(expected))
+            throw new Error("split success is not the canonical aggregate successor");
+    }
+    else if (next.aggregateCloseout)
+        throw new Error("non-success successor may not carry aggregate closeout");
+    return next;
+}
+const commandBase = { operationId: idSchema, expectedRevision: positiveIntegerSchema, expectedParentDigest: digestSchema, expectedManifestDigest: digestSchema };
+export const frontendSplitWakeupCommandSchema = z.object(commandBase).strict();
+export const frontendSplitChildCallbackCommandSchema = z.object({ ...commandBase, observation: frontendSplitChildObservationSchema }).strict();
+export const frontendSplitIntegrationCallbackCommandSchema = z.object({ ...commandBase, completion: completeFrontendSplitIntegrationInputSchema }).strict();
+export const frontendSplitFinalizeCommandSchema = z.object(commandBase).strict();
+function commandFreshnessMismatch(projection, command) {
+    if (projection.parent.operationId !== command.operationId)
+        return "operationId";
+    if (projection.revision !== command.expectedRevision)
+        return "expectedRevision";
+    if (projection.parent.digest !== command.expectedParentDigest)
+        return "expectedParentDigest";
+    if (projection.manifest.digest !== command.expectedManifestDigest)
+        return "expectedManifestDigest";
+    return undefined;
+}
+function assertCurrent(raw, command) {
+    const projection = frontendSplitProjectionSchema.parse(raw);
+    if (commandFreshnessMismatch(projection, command))
+        throw new Error("frontend split command freshness mismatch");
+    return projection;
+}
+function executionForParent(parent) {
+    return buildFrontendOperationExecution({ kind: "split-parent", operationId: parent.operationId, operationRevision: parent.operationRevision, sourceRunId: parent.sourceRunId, sourceDigest: parent.sourceDigest, generation: parent.generation, parentRecordDigest: parent.digest });
+}
+function nextProjection(current, patch) {
+    return frontendSplitProjectionSchema.parse({ ...current, ...patch, revision: current.revision + 1 });
+}
+export class FrontendSplitOrchestrator {
+    ports;
+    constructor(ports) {
+        this.ports = ports;
+    }
+    async loadProjection(operationId) {
+        const loaded = await this.ports.load(operationId);
+        if (!loaded)
+            throw new Error(`frontend split operation not found: ${operationId}`);
+        return frontendSplitProjectionSchema.parse(loaded);
+    }
+    async loadCurrent(command) {
+        return assertCurrent(await this.loadProjection(command.operationId), command);
+    }
+    async loadCallbackCurrent(command, fact) {
+        const projection = await this.loadProjection(command.operationId);
+        const mismatch = commandFreshnessMismatch(projection, command);
+        if (!mismatch)
+            return projection;
+        await this.ports.auditStale({
+            operationId: command.operationId,
+            reason: "frontend split command freshness mismatch",
+            fact: { mismatch, callbackFact: fact },
+        });
+        return undefined;
+    }
+    cas(current, next) {
+        return this.ports.compareAndSwap({ operationId: current.parent.operationId, expectedRevision: current.revision, expectedExecutionDigest: current.execution.digest, expectedParentDigest: current.parent.digest, next });
+    }
+    async wakeupChildren(raw) {
+        const command = frontendSplitWakeupCommandSchema.parse(raw);
+        const current = await this.loadCurrent(command);
+        const materialized = [];
+        const scheduled = [];
+        for (const childId of current.manifest.topologicalOrder) {
+            const child = current.manifest.children.find((item) => item.childId === childId);
+            const result = await this.ports.materialize({ kind: "child", parentOperationId: current.parent.operationId, manifestDigest: current.manifest.digest, generation: current.parent.generation, taskId: child.taskId, operationId: child.operationId, payloadDigest: current.manifest.digest, allowedPaths: child.allowedPaths, writeSet: child.writeSet, verifyRefs: current.manifest.verifyRefs });
+            if (result.taskId !== child.taskId || result.operationId !== child.operationId)
+                throw new Error("child materialization binding drift");
+            materialized.push(child.operationId);
+            const childControllerOwnsScheduling = current.parent.observations.some((observation) => observation.childId === childId && observation.operationId === child.operationId);
+            if (!childControllerOwnsScheduling && isFrontendSplitChildReady(current.parent, current.manifest, childId)) {
+                await this.ports.schedule({ operationId: child.operationId, generation: current.parent.generation, bindingDigest: current.parent.digest });
+                scheduled.push(child.operationId);
+            }
+        }
+        return { materialized, scheduled };
+    }
+    async childCallback(raw) {
+        const command = frontendSplitChildCallbackCommandSchema.parse(raw);
+        const current = await this.loadCallbackCurrent(command, command.observation);
+        if (!current)
+            return { outcome: "ignored-stale" };
+        const reduced = observeFrontendSplitChild(current.parent, current.manifest, command.observation);
+        if (reduced.outcome === "ignored-stale") {
+            await this.ports.auditStale({ operationId: command.operationId, reason: reduced.auditFact.reason, fact: reduced.auditFact });
+            return { outcome: "ignored-stale" };
+        }
+        return this.cas(current, nextProjection(current, { parent: reduced.parent, execution: executionForParent(reduced.parent) }));
+    }
+    async wakeupIntegration(raw) {
+        const command = frontendSplitWakeupCommandSchema.parse(raw);
+        const current = await this.loadCurrent(command);
+        const integration = current.manifest.integration;
+        const materializeAndSchedule = async (bindingDigest) => {
+            if (!integration.required || !integration.operationId)
+                return;
+            const taskId = `${current.parent.operationId}:integration`;
+            const result = await this.ports.materialize({ kind: "integration", parentOperationId: current.parent.operationId, manifestDigest: current.manifest.digest, generation: current.parent.generation, taskId, operationId: integration.operationId, payloadDigest: bindingDigest, allowedPaths: integration.allowedPaths, writeSet: integration.writeSet, verifyRefs: integration.verifyRefs });
+            if (result.taskId !== taskId || result.operationId !== integration.operationId)
+                throw new Error("integration materialization binding drift");
+            await this.ports.schedule({ operationId: integration.operationId, generation: current.parent.generation, bindingDigest });
+        };
+        if (current.parent.phase === "awaiting-integration") {
+            if (!integration.required || !current.candidateBinding)
+                return { outcome: "not-ready" };
+            await materializeAndSchedule(current.candidateBinding.digest);
+            return { outcome: "scheduled-existing" };
+        }
+        const joined = prepareFrontendSplitJoin(current.parent, current.manifest);
+        if (joined.outcome === "not-ready")
+            return { outcome: "not-ready" };
+        if (integration.required) {
+            const taskId = `${current.parent.operationId}:integration`;
+            const result = await this.ports.materialize({ kind: "integration", parentOperationId: current.parent.operationId, manifestDigest: current.manifest.digest, generation: current.parent.generation, taskId, operationId: integration.operationId, payloadDigest: joined.binding.digest, allowedPaths: integration.allowedPaths, writeSet: integration.writeSet, verifyRefs: integration.verifyRefs });
+            if (result.taskId !== taskId || result.operationId !== integration.operationId)
+                throw new Error("integration materialization binding drift");
+        }
+        const next = nextProjection(current, { parent: joined.parent, execution: executionForParent(joined.parent), candidateBinding: joined.binding });
+        const applied = await this.cas(current, next);
+        if (applied.outcome === "applied" && integration.required)
+            await this.ports.schedule({ operationId: integration.operationId, generation: current.parent.generation, bindingDigest: joined.binding.digest });
+        return applied;
+    }
+    async integrationCallback(raw) {
+        const command = frontendSplitIntegrationCallbackCommandSchema.parse(raw);
+        const current = await this.loadCallbackCurrent(command, command.completion);
+        if (!current)
+            return { outcome: "ignored-stale" };
+        if (!current.candidateBinding)
+            throw new Error("candidate binding is missing");
+        const completed = completeFrontendSplitIntegration(current.parent, current.manifest, current.candidateBinding, command.completion);
+        if (completed.outcome === "ignored-stale") {
+            await this.ports.auditStale({ operationId: command.operationId, reason: completed.reason, fact: command.completion });
+            return { outcome: "ignored-stale" };
+        }
+        return this.cas(current, nextProjection(current, { parent: completed.parent, execution: executionForParent(completed.parent), integrationBinding: completed.binding }));
+    }
+    async finalize(raw) {
+        const command = frontendSplitFinalizeCommandSchema.parse(raw);
+        const current = await this.loadCurrent(command);
+        if (!current.candidateBinding)
+            throw new Error("candidate binding is missing");
+        const childCloseoutFacts = [];
+        for (const child of current.candidateBinding.children) {
+            childCloseoutFacts.push(await this.ports.loadChildCloseoutFacts({ childId: child.childId, closeoutRef: child.closeoutRef }));
+        }
+        const aggregate = buildFrontendSplitAggregateCloseout(current.parent, current.manifest, current.candidateBinding, current.integrationBinding, childCloseoutFacts);
+        return this.ports.settleAggregate({
+            operationId: current.parent.operationId,
+            expectedRevision: current.revision,
+            expectedExecutionDigest: current.execution.digest,
+            expectedParentDigest: current.parent.digest,
+            expectedManifestDigest: current.manifest.digest,
+            expectedCandidateBindingDigest: current.candidateBinding.digest,
+            expectedIntegrationBindingDigest: current.integrationBinding?.digest,
+            childCloseoutFacts,
+            aggregate,
+        });
+    }
+}