@tea-agent/loop-agent 0.41.1-beta.0 → 0.42.0-next.1

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

@@ -1,203 +0,0 @@
-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,
-        });
-    }
-}