@tangle-network/agent-provider-tangle 0.14.0 → 0.14.2

package/dist/tangle-workspace-branching.js

@@ -1,5 +1,6 @@
 import { ConfidentialAttestationSchema, ConfidentialExecutionRequestSchema, ForkedEnvironmentRefSchema, WorkspaceCheckpointRefSchema, WorkspaceCheckpointRequestSchema, WorkspaceCleanupAcknowledgementSchema, WorkspaceCleanupRequestSchema, WorkspaceForkRequestSchema, WorkspaceOperationLookupRequestSchema, WorkspaceCheckpointResultSchema, WorkspaceCheckpointLookupResultSchema, WorkspaceForkResultSchema, WorkspaceForkLookupResultSchema, canonicalCandidateDigest, confidentialExecutionVerified, sha256Bytes, } from "@tangle-network/agent-interface";
 import { awaitWithSignal, boundedIdentifier, boundedString, assertBoundedJson, MAX_LIST_RESULTS, MAX_STRING_LENGTH, SANDBOX_LIST_PAGE_SIZE, } from "./tangle-contract-safety.js";
+import { encodeTangleConfidentialAttestationQuote, MAX_TEE_EVIDENCE_BYTES, MAX_TEE_MEASUREMENT_BYTES, } from "./tangle-confidential-attestation.js";
 /**
  * Namespace used for provider recovery metadata.
  *
@@ -20,7 +21,9 @@ const MAX_MARKER_CHUNKS = 512;
  * accepts it is exact-optional, so an explicit `undefined` is not an absent key.
  */
 export function confidentialVerifierOption(verifier) {
-    return verifier === undefined ? {} : { confidentialAttestationVerifier: verifier };
+    return verifier === undefined
+        ? {}
+        : { confidentialAttestationVerifier: verifier };
 }
 /**
  * Build the exact workspace contract over the managed Sandbox operations.
@@ -50,20 +53,32 @@ export function createTangleWorkspaceBranching(options) {
         if (local) {
             return local.request.requestDigest === request.requestDigest
                 ? { state: "known", record: local }
-                : { state: "conflict", existingRequestDigest: local.request.requestDigest };
+                : {
+                    state: "conflict",
+                    existingRequestDigest: local.request.requestDigest,
+                };
         }
         const recovered = await findCheckpointByKey(box, request.idempotencyKey, signal);
         if (recovered === undefined) {
-            return { state: "undecided", message: "Sandbox checkpoint inventory is unavailable" };
+            return {
+                state: "undecided",
+                message: "Sandbox checkpoint inventory is unavailable",
+            };
         }
         if (!recovered)
             return { state: "absent" };
         if (recovered.marker.requestDigest !== request.requestDigest) {
-            return { state: "conflict", existingRequestDigest: recovered.marker.requestDigest };
+            return {
+                state: "conflict",
+                existingRequestDigest: recovered.marker.requestDigest,
+            };
         }
         const record = checkpointRecordFromSnapshot(recovered.marker.request, recovered.snapshot);
         if (!record) {
-            return { state: "undecided", message: "Sandbox checkpoint metadata is invalid" };
+            return {
+                state: "undecided",
+                message: "Sandbox checkpoint metadata is invalid",
+            };
         }
         checkpoints.set(request.idempotencyKey, record);
         return { state: "known", record };
@@ -74,26 +89,45 @@ export function createTangleWorkspaceBranching(options) {
         if (local) {
             return local.request.requestDigest === request.requestDigest
                 ? { state: "known", record: local }
-                : { state: "conflict", existingRequestDigest: local.request.requestDigest };
+                : {
+                    state: "conflict",
+                    existingRequestDigest: local.request.requestDigest,
+                };
         }
         const recovered = await findForkByKey(client, box, provider, request.idempotencyKey, signal);
         if (recovered === undefined) {
-            return { state: "undecided", message: "Sandbox child inventory is unavailable" };
+            return {
+                state: "undecided",
+                message: "Sandbox child inventory is unavailable",
+            };
         }
         if (!recovered)
             return { state: "absent" };
         if (recovered.marker.requestDigest !== request.requestDigest) {
-            return { state: "conflict", existingRequestDigest: recovered.marker.requestDigest };
+            return {
+                state: "conflict",
+                existingRequestDigest: recovered.marker.requestDigest,
+            };
         }
         const child = await completeForkChild(client, recovered.child, signal);
         if (!child) {
-            return { state: "undecided", message: "Sandbox fork child identity is incomplete" };
+            return {
+                state: "undecided",
+                message: "Sandbox fork child identity is incomplete",
+            };
         }
         const environment = await environmentFromChild(recovered.marker.request, child, provider, child.createdAt, options.confidentialAttestationVerifier, signal);
         if (!environment) {
-            return { state: "undecided", message: "Sandbox fork child identity is incomplete" };
-        }
-        const record = { request: recovered.marker.request, environment, child: recovered.child };
+            return {
+                state: "undecided",
+                message: "Sandbox fork child identity is incomplete",
+            };
+        }
+        const record = {
+            request: recovered.marker.request,
+            environment,
+            child,
+        };
         forks.set(request.idempotencyKey, record);
         return { state: "known", record };
     };
@@ -296,14 +330,34 @@ export function createTangleWorkspaceBranching(options) {
         const returnedChild = result.children[0];
         const child = await completeForkChild(client, returnedChild, operation?.signal);
         if (!child) {
-            return forkUnknown(request, "Sandbox fork returned a child without a complete identity", true);
-        }
-        const childMarker = forkMarkerFromMetadata(child.metadata, request.idempotencyKey);
-        if (childMarker && childMarker.requestDigest !== request.requestDigest) {
-            return forkConflict(request, childMarker.requestDigest);
+            const compensation = forkMarkerFromMetadata(returnedChild.metadata) === undefined
+                ? await compensateUnmarkedForkChild(result, returnedChild, operation?.signal)
+                : "not_attempted";
+            const removed = compensation === "destroyed" || compensation === "already_absent";
+            return forkUnknown(request, removed
+                ? "Sandbox fork returned a child without a complete identity; the newly created child was removed"
+                : compensation === "unconfirmed"
+                    ? "Sandbox fork returned a child without a complete identity; child cleanup was not confirmed"
+                    : "Sandbox fork returned a child without a complete identity", !removed);
+        }
+        const childMarker = forkMarkerFromMetadata(child.metadata);
+        if (childMarker) {
+            if (!markerBelongsToSource(childMarker, provider, box.id)) {
+                return forkUnknown(request, "Sandbox fork returned a child marked for another source", true);
+            }
+            if (childMarker.idempotencyKey !== request.idempotencyKey ||
+                childMarker.requestDigest !== request.requestDigest) {
+                return forkConflict(request, childMarker.requestDigest);
+            }
         }
         if (!childMarker) {
-            return forkUnknown(request, "Sandbox fork acknowledgement omitted its provider recovery marker", true);
+            const compensation = await compensateUnmarkedForkChild(result, child, operation?.signal);
+            const removed = compensation === "destroyed" || compensation === "already_absent";
+            return forkUnknown(request, removed
+                ? "Sandbox fork acknowledgement omitted its provider recovery marker; the newly created child was removed"
+                : compensation === "unconfirmed"
+                    ? "Sandbox fork acknowledgement omitted its provider recovery marker; child cleanup was not confirmed"
+                    : "Sandbox fork acknowledgement omitted its provider recovery marker", !removed);
         }
         const environment = await environmentFromChild(request, child, provider, child.createdAt, options.confidentialAttestationVerifier, operation?.signal);
         if (!environment) {
@@ -468,7 +522,8 @@ function checkpointRecordFromSnapshot(request, snapshot) {
 async function environmentFromChild(request, child, provider, createdAt, verifier, signal) {
     signal?.throwIfAborted();
     const environmentId = safeIdentifier(child.id);
-    if (!environmentId || environmentId === request.checkpoint.source.environmentId) {
+    if (!environmentId ||
+        environmentId === request.checkpoint.source.environmentId) {
         return undefined;
     }
     if (createdAt === undefined)
@@ -504,7 +559,9 @@ async function environmentFromChild(request, child, provider, createdAt, verifie
         createdAt: normalizedCreatedAt,
         placement: request.placement,
         confidentialRequested: request.confidential?.requested === true,
-        ...(attestation === undefined ? {} : { confidentialAttestation: attestation }),
+        ...(attestation === undefined
+            ? {}
+            : { confidentialAttestation: attestation }),
         ...(attestation === undefined ? {} : { confidential: true }),
         ...(metadata === undefined ? {} : { metadata }),
     });
@@ -513,7 +570,8 @@ async function environmentFromChild(request, child, provider, createdAt, verifie
 }
 async function confidentialAttestationForChild(request, child, provider, verifier, signal) {
     const confidential = ConfidentialExecutionRequestSchema.parse(request.confidential);
-    if (!confidential.requested || typeof child.getTeeAttestation !== "function") {
+    if (!confidential.requested ||
+        typeof child.getTeeAttestation !== "function") {
         return undefined;
     }
     let response;
@@ -532,7 +590,7 @@ async function confidentialAttestationForChild(request, child, provider, verifie
         return undefined;
     }
     const measurement = sha256Bytes(Uint8Array.from(response.attestation.measurement));
-    const quote = encodeJson(response.attestation);
+    const quote = encodeTangleConfidentialAttestationQuote(response.attestation);
     if (quote === undefined)
         return undefined;
     let verifiedAt;
@@ -586,7 +644,8 @@ async function confidentialAttestationForChild(request, child, provider, verifie
         !safeIdentifier(verification.providerKeyId) ||
         !safeString(verification.providerSignature) ||
         verification.providerSignature === quote ||
-        (verification.measurement !== undefined && verification.measurement !== measurement)) {
+        (verification.measurement !== undefined &&
+            verification.measurement !== measurement)) {
         return undefined;
     }
     const attestation = ConfidentialAttestationSchema.safeParse({
@@ -607,23 +666,23 @@ async function confidentialAttestationForChild(request, child, provider, verifie
         : undefined;
 }
 function validTeeReport(report) {
-    return !!report &&
+    return (!!report &&
         safeString(report.tee_type) !== undefined &&
         Array.isArray(report.evidence) &&
-        report.evidence.length <= MAX_STRING_LENGTH &&
+        report.evidence.length <= MAX_TEE_EVIDENCE_BYTES &&
         report.evidence.every((value) => Number.isInteger(value) && value >= 0 && value <= 255) &&
         Array.isArray(report.measurement) &&
-        report.measurement.length <= MAX_STRING_LENGTH &&
+        report.measurement.length <= MAX_TEE_MEASUREMENT_BYTES &&
         report.measurement.every((value) => Number.isInteger(value) && value >= 0 && value <= 255) &&
         Number.isFinite(report.timestamp) &&
-        report.timestamp > 0;
+        report.timestamp > 0);
 }
 function validSnapshotResult(result) {
-    return !!result &&
+    return (!!result &&
         safeIdentifier(result.snapshotId) !== undefined &&
         validDate(result.createdAt) &&
         Array.isArray(result.tags) &&
-        result.tags.every((tag) => safeString(tag) !== undefined);
+        result.tags.every((tag) => safeString(tag) !== undefined));
 }
 function validSnapshotInfo(snapshot, sandboxId) {
     return (validSnapshotResult(snapshot) &&
@@ -631,14 +690,14 @@ function validSnapshotInfo(snapshot, sandboxId) {
         (sandboxId === undefined || snapshot.sandboxId === sandboxId));
 }
 function validForkResult(result) {
-    return !!result &&
+    return (!!result &&
         Array.isArray(result.children) &&
         result.children.every((child) => child !== null &&
             typeof child === "object" &&
             safeIdentifier(child.id) !== undefined) &&
         result.requestedCount === 1 &&
         result.materializedCount === result.children.length &&
-        typeof result.complete === "boolean";
+        typeof result.complete === "boolean");
 }
 function checkpointMarkerTags(request) {
     const marker = {
@@ -802,7 +861,9 @@ async function findManagedCheckpoint(box, provider, id, expected, signal) {
                     canonicalCandidateDigest(expected.source))) {
             return false;
         }
-        return (await checkpointOperationSucceeded(box, marker, signal)) ? true : "unknown";
+        return (await checkpointOperationSucceeded(box, marker, signal))
+            ? true
+            : "unknown";
     }
     catch {
         signal?.throwIfAborted();
@@ -839,7 +900,9 @@ async function findForkChildById(client, box, provider, id, signal) {
         const marker = forkMarkerFromMetadata(child.metadata);
         if (!marker || !markerBelongsToSource(marker, provider, box.id))
             return undefined;
-        return (await forkOperationSucceeded(box, marker, signal)) ? child : undefined;
+        return (await forkOperationSucceeded(box, marker, signal))
+            ? child
+            : undefined;
     }
     catch {
         signal?.throwIfAborted();
@@ -847,21 +910,26 @@ async function findForkChildById(client, box, provider, id, signal) {
     }
 }
 /**
- * Resolve a complete child identity when an inventory entry omits its time.
+ * Resolve a complete child identity when an acknowledgement omits durable data.
  *
- * The current Sandbox SDK includes `createdAt` on branch children. A provider
- * wrapper may omit it, so recover the same child by id before claiming a
- * durable environment instead of inventing a timestamp.
+ * A branch response can precede a richer registry read during a rolling
+ * deployment. Recover the exact child when its creation time or provider
+ * marker is absent. Never invent either field from the request.
  */
 async function completeForkChild(client, child, signal) {
-    if (child.createdAt !== undefined)
+    if (child.createdAt !== undefined &&
+        forkMarkerFromMetadata(child.metadata) !== undefined) {
         return child;
-    if (typeof client.get !== "function" || safeIdentifier(child.id) === undefined) {
+    }
+    if (typeof client.get !== "function" ||
+        safeIdentifier(child.id) === undefined) {
         return undefined;
     }
     try {
         const resolved = await awaitWithSignal(client.get(child.id, signal ? { signal } : undefined), signal);
-        if (!resolved || resolved.id !== child.id || resolved.createdAt === undefined) {
+        if (!resolved ||
+            resolved.id !== child.id ||
+            resolved.createdAt === undefined) {
             return undefined;
         }
         return resolved;
@@ -871,6 +939,26 @@ async function completeForkChild(client, child, signal) {
         return undefined;
     }
 }
+/** Remove only a child this exact call confirmed it created. */
+async function compensateUnmarkedForkChild(result, child, signal) {
+    if (result.idempotency?.outcome !== "created")
+        return "not_attempted";
+    if (typeof child.delete !== "function")
+        return "unconfirmed";
+    try {
+        const acknowledgement = (await awaitWithSignal(child.delete(), signal));
+        if (acknowledgement?.sandboxId !== child.id ||
+            (acknowledgement.outcome !== "destroyed" &&
+                acknowledgement.outcome !== "already_absent")) {
+            return "unconfirmed";
+        }
+        return acknowledgement.outcome;
+    }
+    catch {
+        signal?.throwIfAborted();
+        return "unconfirmed";
+    }
+}
 async function findBlockingForks(box, client, provider, checkpointId, signal) {
     const candidates = await listMarkedForkChildren(client, box, provider, undefined, signal);
     if (candidates === undefined)
@@ -958,7 +1046,9 @@ async function listMarkedForkChildren(client, box, provider, key, signal) {
         return undefined;
     const marked = [];
     for (const child of children) {
-        if (!child || typeof child !== "object" || safeIdentifier(child.id) === undefined) {
+        if (!child ||
+            typeof child !== "object" ||
+            safeIdentifier(child.id) === undefined) {
             return undefined;
         }
         if (child.id === box.id)
@@ -997,13 +1087,16 @@ function currentCheckpointMarkerFromTags(tags, key, base) {
     const keyTag = tags.find((tag) => tag.startsWith(`${base}-key-`));
     if (keyTag &&
         key !== undefined &&
-        keyTag.slice(`${base}-key-`.length) !== markerKeyDigest(key).replace(":", "-")) {
+        keyTag.slice(`${base}-key-`.length) !==
+            markerKeyDigest(key).replace(":", "-")) {
         return undefined;
     }
     const chunks = tags
         .map((tag) => {
         const match = tag.match(new RegExp(`^${escapeRegExp(base)}-material-(\\d+)-(\\d+)-([A-Za-z0-9_-]+)$`));
-        return match ? { index: Number(match[1]), total: Number(match[2]), chunk: match[3] } : undefined;
+        return match
+            ? { index: Number(match[1]), total: Number(match[2]), chunk: match[3] }
+            : undefined;
     })
         .filter((value) => value !== undefined)
         .sort((left, right) => left.index - right.index);
@@ -1053,12 +1146,17 @@ function checkpointMarkerFromUnknown(value, key, legacy = false) {
     if (!value || typeof value !== "object")
         return undefined;
     const parsed = value;
-    if (parsed.version !== 1 || parsed.kind !== "checkpoint" || typeof parsed.idempotencyKey !== "string" || typeof parsed.requestDigest !== "string")
+    if (parsed.version !== 1 ||
+        parsed.kind !== "checkpoint" ||
+        typeof parsed.idempotencyKey !== "string" ||
+        typeof parsed.requestDigest !== "string")
         return undefined;
     if (key !== undefined && parsed.idempotencyKey !== key)
         return undefined;
     const request = WorkspaceCheckpointRequestSchema.safeParse(parsed.request);
-    if (!request.success || request.data.idempotencyKey !== parsed.idempotencyKey || request.data.requestDigest !== parsed.requestDigest)
+    if (!request.success ||
+        request.data.idempotencyKey !== parsed.idempotencyKey ||
+        request.data.requestDigest !== parsed.requestDigest)
         return undefined;
     return {
         version: 1,
@@ -1079,14 +1177,25 @@ function forkMarkerFromMetadata(metadata, key) {
     if (!value || typeof value !== "object")
         return undefined;
     const parsed = value;
-    if (parsed.version !== 1 || parsed.kind !== "fork" || typeof parsed.idempotencyKey !== "string" || typeof parsed.requestDigest !== "string")
+    if (parsed.version !== 1 ||
+        parsed.kind !== "fork" ||
+        typeof parsed.idempotencyKey !== "string" ||
+        typeof parsed.requestDigest !== "string")
         return undefined;
     if (key !== undefined && parsed.idempotencyKey !== key)
         return undefined;
     const request = WorkspaceForkRequestSchema.safeParse(parsed.request);
-    if (!request.success || request.data.idempotencyKey !== parsed.idempotencyKey || request.data.requestDigest !== parsed.requestDigest)
+    if (!request.success ||
+        request.data.idempotencyKey !== parsed.idempotencyKey ||
+        request.data.requestDigest !== parsed.requestDigest)
         return undefined;
-    return { version: 1, kind: "fork", idempotencyKey: parsed.idempotencyKey, requestDigest: parsed.requestDigest, request: request.data };
+    return {
+        version: 1,
+        kind: "fork",
+        idempotencyKey: parsed.idempotencyKey,
+        requestDigest: parsed.requestDigest,
+        request: request.data,
+    };
 }
 /**
  * Turn a failed create into a conflict only from provider-owned material.
@@ -1134,7 +1243,11 @@ async function forkConflictFromRemote(client, box, provider, request, verifier,
  */
 function lookupOutcomeFromSandbox(lookup, kind) {
     if (!lookup || lookup.kind !== kind) {
-        return { absent: false, message: `Sandbox returned no ${kind} lookup`, retryable: true };
+        return {
+            absent: false,
+            message: `Sandbox returned no ${kind} lookup`,
+            retryable: true,
+        };
     }
     if (lookup.outcome === "conflict") {
         return {
@@ -1143,70 +1256,173 @@ function lookupOutcomeFromSandbox(lookup, kind) {
             retryable: false,
         };
     }
-    if (lookup.outcome !== "not_found" && (lookup.outcome === "unknown" || lookup.state !== "succeeded")) {
-        return { absent: false, message: `Sandbox ${kind} operation is not decided`, retryable: true };
+    if (lookup.outcome !== "not_found" &&
+        (lookup.outcome === "unknown" || lookup.state !== "succeeded")) {
+        return {
+            absent: false,
+            message: `Sandbox ${kind} operation is not decided`,
+            retryable: true,
+        };
     }
     return { absent: true };
 }
 function checkpointSuccess(request, checkpoint, status) {
-    return WorkspaceCheckpointResultSchema.parse({ status, idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest, checkpoint });
+    return WorkspaceCheckpointResultSchema.parse({
+        status,
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+        checkpoint,
+    });
 }
 function checkpointConflict(request, existingRequestDigest) {
-    return WorkspaceCheckpointResultSchema.parse({ status: "conflict", idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest, existingRequestDigest });
+    return WorkspaceCheckpointResultSchema.parse({
+        status: "conflict",
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+        existingRequestDigest,
+    });
 }
 function checkpointUnknown(request, message, retryable) {
-    return WorkspaceCheckpointResultSchema.parse({ status: "unknown", idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest, message: boundedString(message, "Tangle checkpoint error"), retryable });
+    return WorkspaceCheckpointResultSchema.parse({
+        status: "unknown",
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+        message: boundedString(message, "Tangle checkpoint error"),
+        retryable,
+    });
 }
 function checkpointFound(request, checkpoint) {
-    return WorkspaceCheckpointLookupResultSchema.parse({ status: "found", idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest, checkpoint });
+    return WorkspaceCheckpointLookupResultSchema.parse({
+        status: "found",
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+        checkpoint,
+    });
 }
 function checkpointNotFound(request) {
-    return WorkspaceCheckpointLookupResultSchema.parse({ status: "not_found", idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest });
+    return WorkspaceCheckpointLookupResultSchema.parse({
+        status: "not_found",
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+    });
 }
 function checkpointLookupConflict(request, existingRequestDigest) {
-    return WorkspaceCheckpointLookupResultSchema.parse({ status: "conflict", idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest, existingRequestDigest });
+    return WorkspaceCheckpointLookupResultSchema.parse({
+        status: "conflict",
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+        existingRequestDigest,
+    });
 }
 function checkpointLookupUnknown(request, message, retryable) {
-    return WorkspaceCheckpointLookupResultSchema.parse({ status: "unknown", idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest, message: boundedString(message, "Tangle checkpoint lookup error"), retryable });
+    return WorkspaceCheckpointLookupResultSchema.parse({
+        status: "unknown",
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+        message: boundedString(message, "Tangle checkpoint lookup error"),
+        retryable,
+    });
 }
 function forkSuccess(request, environment, status) {
-    return WorkspaceForkResultSchema.parse({ status, idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest, environment });
+    return WorkspaceForkResultSchema.parse({
+        status,
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+        environment,
+    });
 }
 function forkConflict(request, existingRequestDigest) {
-    return WorkspaceForkResultSchema.parse({ status: "conflict", idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest, existingRequestDigest });
+    return WorkspaceForkResultSchema.parse({
+        status: "conflict",
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+        existingRequestDigest,
+    });
 }
 function forkUnknown(request, message, retryable) {
-    return WorkspaceForkResultSchema.parse({ status: "unknown", idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest, message: boundedString(message, "Tangle fork error"), retryable });
+    return WorkspaceForkResultSchema.parse({
+        status: "unknown",
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+        message: boundedString(message, "Tangle fork error"),
+        retryable,
+    });
 }
 function forkFound(request, environment) {
-    return WorkspaceForkLookupResultSchema.parse({ status: "found", idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest, environment });
+    return WorkspaceForkLookupResultSchema.parse({
+        status: "found",
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+        environment,
+    });
 }
 function forkNotFound(request) {
-    return WorkspaceForkLookupResultSchema.parse({ status: "not_found", idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest });
+    return WorkspaceForkLookupResultSchema.parse({
+        status: "not_found",
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+    });
 }
 function forkLookupConflict(request, existingRequestDigest) {
-    return WorkspaceForkLookupResultSchema.parse({ status: "conflict", idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest, existingRequestDigest });
+    return WorkspaceForkLookupResultSchema.parse({
+        status: "conflict",
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+        existingRequestDigest,
+    });
 }
 function forkLookupUnknown(request, message, retryable) {
-    return WorkspaceForkLookupResultSchema.parse({ status: "unknown", idempotencyKey: request.idempotencyKey, requestDigest: request.requestDigest, message: boundedString(message, "Tangle fork lookup error"), retryable });
+    return WorkspaceForkLookupResultSchema.parse({
+        status: "unknown",
+        idempotencyKey: request.idempotencyKey,
+        requestDigest: request.requestDigest,
+        message: boundedString(message, "Tangle fork lookup error"),
+        retryable,
+    });
 }
 function cleanupDeleted(request) {
-    return WorkspaceCleanupAcknowledgementSchema.parse({ ...request, status: "deleted" });
+    return WorkspaceCleanupAcknowledgementSchema.parse({
+        ...request,
+        status: "deleted",
+    });
 }
 function cleanupAlreadyAbsent(request) {
-    return WorkspaceCleanupAcknowledgementSchema.parse({ ...request, status: "already_absent" });
+    return WorkspaceCleanupAcknowledgementSchema.parse({
+        ...request,
+        status: "already_absent",
+    });
 }
 function cleanupConflict(request, existingRequestDigest) {
-    return WorkspaceCleanupAcknowledgementSchema.parse({ ...request, status: "conflict", existingRequestDigest, message: "Cleanup operation id is bound to another target" });
+    return WorkspaceCleanupAcknowledgementSchema.parse({
+        ...request,
+        status: "conflict",
+        existingRequestDigest,
+        message: "Cleanup operation id is bound to another target",
+    });
 }
 function cleanupInUse(request, blockingTargetIds) {
-    return WorkspaceCleanupAcknowledgementSchema.parse({ ...request, status: "in_use", blockingTargetIds, message: "Checkpoint is still referenced by forked environments" });
+    return WorkspaceCleanupAcknowledgementSchema.parse({
+        ...request,
+        status: "in_use",
+        blockingTargetIds,
+        message: "Checkpoint is still referenced by forked environments",
+    });
 }
 function cleanupUnknown(request, message, retryable) {
-    return WorkspaceCleanupAcknowledgementSchema.parse({ ...request, status: "unknown", message: boundedString(message, "Tangle cleanup error"), retryable });
+    return WorkspaceCleanupAcknowledgementSchema.parse({
+        ...request,
+        status: "unknown",
+        message: boundedString(message, "Tangle cleanup error"),
+        retryable,
+    });
 }
 function cleanupTransportFailure(request, message, retryable) {
-    return WorkspaceCleanupAcknowledgementSchema.parse({ ...request, status: "transport_failure", message: boundedString(message, "Tangle cleanup transport error"), retryable });
+    return WorkspaceCleanupAcknowledgementSchema.parse({
+        ...request,
+        status: "transport_failure",
+        message: boundedString(message, "Tangle cleanup transport error"),
+        retryable,
+    });
 }
 function isoDate(value) {
     const date = value instanceof Date ? value : new Date(value);
@@ -1225,12 +1441,17 @@ function cloneJson(value) {
     return structuredClone(value);
 }
 function safeIdentifier(value) {
-    if (typeof value !== "string" || value.length === 0 || value.length > 512 || value.trim() !== value)
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > 512 ||
+        value.trim() !== value)
         return undefined;
     return value;
 }
 function safeString(value) {
-    if (typeof value !== "string" || value.length === 0 || value.length > MAX_STRING_LENGTH)
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > MAX_STRING_LENGTH)
         return undefined;
     return value;
 }