mustardscript 0.1.0 → 0.1.2

package/dist/lib/progress.js

@@ -8,19 +8,23 @@ const { performance } = require('node:perf_hooks');
 const { MustardError, callNative } = require('./errors.js');
 const { getAbortSignal, withCancellationSignal } = require('./cancellation.js');
 const {
+  assertSuspendedManifest,
   cloneSnapshotPolicy,
   cloneSnapshotKey,
+  createSuspendedManifest,
   encodeSnapshotPolicy,
+  programIdentity,
   resolveProgressLoadContext,
   snapshotIdentity,
   snapshotKeyDigest,
   snapshotToken,
+  suspendedManifestToken,
 } = require('./policy.js');
 const {
   decodeStructured,
-  encodeResumePayloadCancel,
-  encodeResumePayloadError,
-  encodeResumePayloadValue,
+  encodeResumePayloadCancelBuffer,
+  encodeResumePayloadErrorBuffer,
+  encodeResumePayloadValueBuffer,
 } = require('./structured.js');
 
 const SHARED_PROGRESS_REGISTRY_ROOT = path.join(
@@ -74,44 +78,63 @@ function singleUseRuntimeError() {
 }
 
 function releaseClaimedSnapshot(native, snapshotIdentityValue) {
-  try {
-    callNative(native.releaseProgressSnapshot, snapshotIdentityValue);
-  } finally {
-    releaseSharedProgressSnapshot(snapshotIdentityValue);
-  }
+  void native;
+  releaseSharedProgressSnapshot(snapshotIdentityValue);
 }
 
 function claimSnapshotForLoad(native, snapshotIdentityValue) {
+  void native;
   if (!claimSharedProgressSnapshot(snapshotIdentityValue)) {
     throw singleUseRuntimeError();
   }
-  try {
-    if (!callNative(native.claimProgressSnapshot, snapshotIdentityValue)) {
-      releaseSharedProgressSnapshot(snapshotIdentityValue);
-      throw singleUseRuntimeError();
-    }
-  } catch (error) {
-    if (!(error instanceof MustardError)) {
-      releaseSharedProgressSnapshot(snapshotIdentityValue);
-    }
-    throw error;
-  }
-
   return () => {
     releaseClaimedSnapshot(native, snapshotIdentityValue);
   };
 }
 
 function assertSnapshotNotUsed(native, snapshotIdentityValue) {
-  if (
-    isSharedProgressSnapshotUsed(snapshotIdentityValue) ||
-    callNative(native.isProgressSnapshotUsed, snapshotIdentityValue)
-  ) {
+  void native;
+  if (isSharedProgressSnapshotUsed(snapshotIdentityValue)) {
     throw singleUseRuntimeError();
   }
 }
 
+function isBinaryLike(value) {
+  return Buffer.isBuffer(value) || value instanceof Uint8Array;
+}
+
 function createProgressApi(native) {
+  const programHandleRegistry =
+    typeof FinalizationRegistry === 'function'
+      ? new FinalizationRegistry((programHandle) => {
+          try {
+            callNative(native.releaseProgram, programHandle);
+          } catch {
+            // Best-effort cleanup only; process shutdown can race native teardown.
+          }
+        })
+      : null;
+  const snapshotHandleRegistry =
+    typeof FinalizationRegistry === 'function'
+      ? new FinalizationRegistry((snapshotHandle) => {
+          try {
+            callNative(native.releaseSnapshotHandle, snapshotHandle);
+          } catch {
+            // Best-effort cleanup only; process shutdown can race native teardown.
+          }
+        })
+      : null;
+
+  function assertAuthorizedSuspendedCapability(policy, capability) {
+    if (policy.capabilities.includes(capability)) {
+      return;
+    }
+    throw new MustardError(
+      'Serialization',
+      `snapshot policy rejected unauthorized capability \`${capability}\``,
+    );
+  }
+
   class Progress {
     constructor(
       snapshot,
@@ -121,25 +144,173 @@ function createProgressApi(native) {
       snapshotKey,
       token = undefined,
       claimState = 'unclaimed',
+      suspendedManifest = undefined,
+      suspendedManifestTokenValue = undefined,
+      programHandle = null,
+      program = undefined,
+      programId = undefined,
+      snapshotHandle = null,
+      snapshotId = undefined,
+      snapshotKeyBase64 = undefined,
+      snapshotKeyDigestValue = undefined,
     ) {
-      this.capability = capability;
-      this.args = args;
-      this.#snapshot = Buffer.from(snapshot);
-      this.#snapshotIdentity = snapshotIdentity(this.#snapshot);
+      this.#capability = capability;
+      this.#args = structuredClone(args);
+      this.capability = this.#capability;
+      this.args = structuredClone(this.#args);
+      this.#snapshot =
+        snapshot === undefined || snapshot === null ? null : Buffer.from(snapshot);
+      this.#snapshotIdentity =
+        typeof snapshotId === 'string' && snapshotId.length > 0
+          ? snapshotId
+          : this.#snapshot !== null
+            ? snapshotIdentity(this.#snapshot)
+            : null;
       this.#snapshotKey = cloneSnapshotKey(snapshotKey);
-      this.#snapshotKeyDigest = snapshotKeyDigest(this.#snapshotKey);
-      this.#snapshotToken = token ?? snapshotToken(this.#snapshot, this.#snapshotKey);
+      this.#snapshotKeyBase64 =
+        typeof snapshotKeyBase64 === 'string' && snapshotKeyBase64.length > 0
+          ? snapshotKeyBase64
+          : this.#snapshotKey.toString('base64');
+      this.#snapshotKeyDigest =
+        typeof snapshotKeyDigestValue === 'string' && snapshotKeyDigestValue.length > 0
+          ? snapshotKeyDigestValue
+          : snapshotKeyDigest(this.#snapshotKey);
+      this.#snapshotToken =
+        typeof token === 'string' && token.length > 0
+          ? token
+          : this.#snapshot !== null
+            ? snapshotToken(this.#snapshot, this.#snapshotKey, this.#snapshotIdentity)
+            : null;
+      this.#suspendedManifest =
+        suspendedManifest ?? createSuspendedManifest(this.#capability, this.#args);
+      this.#suspendedManifestToken =
+        typeof suspendedManifestTokenValue === 'string' && suspendedManifestTokenValue.length > 0
+          ? suspendedManifestTokenValue
+          : this.#snapshotIdentity === null
+            ? null
+            : suspendedManifestToken(
+                this.#snapshotIdentity,
+                this.#suspendedManifest,
+                this.#snapshotKey,
+              );
       this.#policy = cloneSnapshotPolicy(policy);
+      this.#snapshotPolicyJson =
+        this.#snapshotIdentity === null || this.#snapshotToken === null
+          ? null
+          : encodeSnapshotPolicy(this.#policy, {
+              snapshotId: this.#snapshotIdentity,
+              snapshotKeyBase64: this.#snapshotKeyBase64,
+              snapshotKeyDigest: this.#snapshotKeyDigest,
+              snapshotToken: this.#snapshotToken,
+            });
       this.#claimState = claimState;
+      this.#program = program === undefined || program === null ? null : Buffer.from(program);
+      this.#programIdentity =
+        typeof programId === 'string' && programId.length > 0
+          ? programId
+          : this.#program !== null
+            ? programIdentity(this.#program)
+            : null;
+      this.#programHandle = null;
+      this.#programHandleToken = null;
+      if (typeof programHandle === 'string' && programHandle.length > 0) {
+        this.#programHandle = programHandle;
+        this.#programHandleToken = {};
+        programHandleRegistry?.register(this, programHandle, this.#programHandleToken);
+      }
+      this.#snapshotHandle = null;
+      this.#snapshotHandleToken = null;
+      if (typeof snapshotHandle === 'string' && snapshotHandle.length > 0) {
+        this.#snapshotHandle = snapshotHandle;
+        this.#snapshotHandleToken = {};
+        snapshotHandleRegistry?.register(this, snapshotHandle, this.#snapshotHandleToken);
+      }
     }
 
+    #capability;
+    #args;
     #snapshot;
     #snapshotIdentity;
     #snapshotKey;
+    #snapshotKeyBase64;
     #snapshotKeyDigest;
     #snapshotToken;
+    #suspendedManifest;
+    #suspendedManifestToken;
     #policy;
+    #snapshotPolicyJson;
     #claimState;
+    #program;
+    #programIdentity;
+    #programHandle;
+    #programHandleToken;
+    #snapshotHandle;
+    #snapshotHandleToken;
+
+    #clearSnapshotHandle() {
+      if (this.#snapshotHandleToken !== null) {
+        snapshotHandleRegistry?.unregister(this.#snapshotHandleToken);
+      }
+      this.#snapshotHandle = null;
+      this.#snapshotHandleToken = null;
+    }
+
+    #releaseSnapshotHandle() {
+      if (this.#snapshotHandle === null) {
+        return;
+      }
+      const snapshotHandle = this.#snapshotHandle;
+      this.#clearSnapshotHandle();
+      try {
+        callNative(native.releaseSnapshotHandle, snapshotHandle);
+      } catch {
+        // Best-effort cleanup only.
+      }
+    }
+
+    #ensureSnapshotBytes() {
+      if (this.#snapshot !== null) {
+        return Buffer.from(this.#snapshot);
+      }
+      if (this.#snapshotHandle === null) {
+        throw singleUseRuntimeError();
+      }
+      this.#snapshot = Buffer.from(callNative(native.dumpSnapshotHandle, this.#snapshotHandle));
+      this.#snapshotIdentity ??= snapshotIdentity(this.#snapshot);
+      this.#snapshotToken ??= snapshotToken(
+        this.#snapshot,
+        this.#snapshotKey,
+        this.#snapshotIdentity,
+      );
+      this.#suspendedManifestToken ??= suspendedManifestToken(
+        this.#snapshotIdentity,
+        this.#suspendedManifest,
+        this.#snapshotKey,
+      );
+      this.#snapshotPolicyJson ??= encodeSnapshotPolicy(this.#policy, {
+        snapshotId: this.#snapshotIdentity,
+        snapshotKeyBase64: this.#snapshotKeyBase64,
+        snapshotKeyDigest: this.#snapshotKeyDigest,
+        snapshotToken: this.#snapshotToken,
+      });
+      return Buffer.from(this.#snapshot);
+    }
+
+    #ensureSnapshotPolicyJson() {
+      if (this.#snapshotPolicyJson !== null) {
+        return this.#snapshotPolicyJson;
+      }
+      const snapshot = this.#ensureSnapshotBytes();
+      this.#snapshotIdentity ??= snapshotIdentity(snapshot);
+      this.#snapshotToken ??= snapshotToken(snapshot, this.#snapshotKey, this.#snapshotIdentity);
+      this.#snapshotPolicyJson = encodeSnapshotPolicy(this.#policy, {
+        snapshotId: this.#snapshotIdentity,
+        snapshotKeyBase64: this.#snapshotKeyBase64,
+        snapshotKeyDigest: this.#snapshotKeyDigest,
+        snapshotToken: this.#snapshotToken,
+      });
+      return this.#snapshotPolicyJson;
+    }
 
     #consumeSnapshot() {
       if (this.#claimState === 'consumed') {
@@ -152,34 +323,127 @@ function createProgressApi(native) {
       if (!claimSharedProgressSnapshot(this.#snapshotIdentity)) {
         throw singleUseRuntimeError();
       }
-      try {
-        if (!callNative(native.claimProgressSnapshot, this.#snapshotIdentity)) {
-          releaseSharedProgressSnapshot(this.#snapshotIdentity);
-          throw singleUseRuntimeError();
-        }
-      } catch (error) {
-        if (!(error instanceof MustardError)) {
-          releaseSharedProgressSnapshot(this.#snapshotIdentity);
-        }
-        throw error;
-      }
       this.#claimState = 'consumed';
       return Buffer.from(this.#snapshot);
     }
 
+    #consumeSnapshotHandle() {
+      if (this.#claimState === 'consumed') {
+        throw singleUseRuntimeError();
+      }
+      if (
+        this.#claimState === 'unclaimed' &&
+        this.#snapshotIdentity !== null &&
+        !claimSharedProgressSnapshot(this.#snapshotIdentity)
+      ) {
+        throw singleUseRuntimeError();
+      }
+      if (this.#snapshotHandle === null) {
+        return null;
+      }
+      const snapshotHandle = this.#snapshotHandle;
+      this.#clearSnapshotHandle();
+      this.#claimState = 'consumed';
+      return snapshotHandle;
+    }
+
+    #ensureProgramHandle() {
+      if (this.#programHandle !== null) {
+        return this.#programHandle;
+      }
+      if (this.#program === null) {
+        return null;
+      }
+      const programHandle = callNative(native.loadProgram, Buffer.from(this.#program));
+      this.#programHandle = programHandle;
+      this.#programHandleToken = {};
+      programHandleRegistry?.register(this, programHandle, this.#programHandleToken);
+      return programHandle;
+    }
+
+    #ensureProgramBytes() {
+      if (this.#program !== null) {
+        return Buffer.from(this.#program);
+      }
+      if (this.#programHandle === null) {
+        return null;
+      }
+      this.#program = Buffer.from(callNative(native.dumpProgram, this.#programHandle));
+      this.#programIdentity ??= programIdentity(this.#program);
+      return Buffer.from(this.#program);
+    }
+
+    #resumeWithPayload(payload, signal) {
+      const programHandle = this.#ensureProgramHandle();
+      const snapshotHandle = this.#consumeSnapshotHandle();
+      if (snapshotHandle !== null) {
+        try {
+          const nativeArgs = [snapshotHandle, payload];
+          const step = parseStep(
+            signal === undefined
+              ? callNative(native.resumeSnapshotHandleBuffer, ...nativeArgs)
+              : withCancellationSignal(
+                  native,
+                  native.resumeSnapshotHandleBuffer,
+                  nativeArgs,
+                  signal,
+                ),
+          );
+          return materializeStep(step, this.#policy, this.#snapshotKey, programHandle, this.#program);
+        } finally {
+          try {
+            callNative(native.releaseSnapshotHandle, snapshotHandle);
+          } catch {
+            // Best-effort cleanup only.
+          }
+        }
+      }
+
+      const snapshot = this.#consumeSnapshot();
+      const policyJson = this.#ensureSnapshotPolicyJson();
+      const nativeResume =
+        programHandle === null ? native.resumeProgram : native.resumeDetachedProgram;
+      const nativeArgs =
+        programHandle === null
+          ? [snapshot, payload, policyJson]
+          : [programHandle, snapshot, payload, policyJson];
+      const step = parseStep(
+        signal === undefined
+          ? callNative(nativeResume, ...nativeArgs)
+          : withCancellationSignal(native, nativeResume, nativeArgs, signal),
+      );
+      return materializeStep(step, this.#policy, this.#snapshotKey, programHandle, this.#program);
+    }
+
     get snapshot() {
-      return Buffer.from(this.#snapshot);
+      return this.#ensureSnapshotBytes();
     }
 
     dump() {
-      return {
-        capability: this.capability,
-        args: this.args.slice(),
-        snapshot: this.snapshot,
+      const snapshot = this.#ensureSnapshotBytes();
+      this.#snapshotIdentity ??= snapshotIdentity(snapshot);
+      this.#snapshotToken ??= snapshotToken(snapshot, this.#snapshotKey, this.#snapshotIdentity);
+      this.#suspendedManifestToken ??= suspendedManifestToken(
+        this.#snapshotIdentity,
+        this.#suspendedManifest,
+        this.#snapshotKey,
+      );
+      const dumped = {
+        capability: this.#capability,
+        args: structuredClone(this.#args),
+        snapshot,
         snapshot_id: this.#snapshotIdentity,
         snapshot_key_digest: this.#snapshotKeyDigest,
         token: this.#snapshotToken,
+        suspended_manifest: this.#suspendedManifest,
+        suspended_manifest_token: this.#suspendedManifestToken,
       };
+      const program = this.#ensureProgramBytes();
+      if (program !== null) {
+        dumped.program = program;
+        dumped.program_id = this.#programIdentity ?? programIdentity(program);
+      }
+      return dumped;
     }
 
     resume(value, options = undefined) {
@@ -187,21 +451,7 @@ function createProgressApi(native) {
       if (signal?.aborted) {
         return this.cancel();
       }
-      const payload = encodeResumePayloadValue(value);
-      const policyJson = encodeSnapshotPolicy(this.#policy, {
-        snapshotId: this.#snapshotIdentity,
-        snapshotKey: this.#snapshotKey,
-        snapshotToken: this.#snapshotToken,
-      });
-      const step = parseStep(
-        withCancellationSignal(
-          native,
-          native.resumeProgram,
-          [this.#consumeSnapshot(), payload, policyJson],
-          signal,
-        ),
-      );
-      return materializeStep(step, this.#policy, this.#snapshotKey);
+      return this.#resumeWithPayload(encodeResumePayloadValueBuffer(value), signal);
     }
 
     resumeError(error, options = undefined) {
@@ -209,38 +459,11 @@ function createProgressApi(native) {
       if (signal?.aborted) {
         return this.cancel();
       }
-      const payload = encodeResumePayloadError(error);
-      const policyJson = encodeSnapshotPolicy(this.#policy, {
-        snapshotId: this.#snapshotIdentity,
-        snapshotKey: this.#snapshotKey,
-        snapshotToken: this.#snapshotToken,
-      });
-      const step = parseStep(
-        withCancellationSignal(
-          native,
-          native.resumeProgram,
-          [this.#consumeSnapshot(), payload, policyJson],
-          signal,
-        ),
-      );
-      return materializeStep(step, this.#policy, this.#snapshotKey);
+      return this.#resumeWithPayload(encodeResumePayloadErrorBuffer(error), signal);
     }
 
     cancel() {
-      const policyJson = encodeSnapshotPolicy(this.#policy, {
-        snapshotId: this.#snapshotIdentity,
-        snapshotKey: this.#snapshotKey,
-        snapshotToken: this.#snapshotToken,
-      });
-      const step = parseStep(
-        callNative(
-          native.resumeProgram,
-          this.#consumeSnapshot(),
-          encodeResumePayloadCancel(),
-          policyJson,
-        ),
-      );
-      return materializeStep(step, this.#policy, this.#snapshotKey);
+      return this.#resumeWithPayload(encodeResumePayloadCancelBuffer(), undefined);
     }
 
     static load(state, options = undefined) {
@@ -282,30 +505,168 @@ function createProgressApi(native) {
           'Progress.load() rejected a tampered or unauthenticated snapshot',
         );
       }
+
+      let dumpedProgram;
+      let dumpedProgramId;
+      if (state.program !== undefined) {
+        if (!isBinaryLike(state.program)) {
+          throw new TypeError('Progress.load() requires dumped program bytes as Buffer or Uint8Array');
+        }
+        if (typeof state.program_id !== 'string' || state.program_id.length === 0) {
+          throw new TypeError(
+            'Progress.load() requires dumped program_id metadata when program bytes are present',
+          );
+        }
+        dumpedProgram = Buffer.from(state.program);
+        dumpedProgramId = programIdentity(dumpedProgram);
+        if (dumpedProgramId !== state.program_id) {
+          throw new MustardError(
+            'Serialization',
+            'Progress.load() rejected a tampered or mismatched detached program',
+          );
+        }
+      }
+
       assertSnapshotNotUsed(native, snapshotIdentityValue);
-      const context = resolveProgressLoadContext(state, snapshot, options);
-      const releaseClaim = claimSnapshotForLoad(native, snapshotIdentityValue);
-      try {
-        const inspection = parseSnapshotInspection(
-          callNative(
-            native.inspectSnapshot,
-            snapshot,
-            encodeSnapshotPolicy(context.policy, {
+      const context = resolveProgressLoadContext(
+        state,
+        snapshot,
+        options,
+        snapshotIdentityValue,
+      );
+      const suspendedManifest = assertSuspendedManifest(
+        state,
+        context.snapshotKey,
+        snapshotIdentityValue,
+      );
+      const nativeContextHandle =
+        typeof context.nativeContextHandle === 'string' && context.nativeContextHandle.length > 0
+          ? context.nativeContextHandle
+          : null;
+      const policyJson =
+        nativeContextHandle === null
+          ? encodeSnapshotPolicy(context.policy, {
               snapshotId: state.snapshot_id,
               snapshotKey: context.snapshotKey,
+              snapshotKeyBase64: context.snapshotKeyBase64,
+              snapshotKeyDigest: context.snapshotKeyDigest,
               snapshotToken: state.token,
-            }),
-          ),
-        );
-        return new Progress(
-          snapshot,
-          inspection.capability,
-          inspection.args,
-          context.policy,
-          context.snapshotKey,
-          state.token,
-          'claimed',
-        );
+            })
+          : null;
+      const releaseClaim = claimSnapshotForLoad(native, snapshotIdentityValue);
+      try {
+        let loadedProgramHandle = null;
+        let snapshotHandle = null;
+        const loadSnapshotHandle = () => {
+          if (dumpedProgram === undefined) {
+            return nativeContextHandle === null
+              ? callNative(native.loadSnapshotHandle, snapshot, policyJson)
+              : callNative(
+                  native.loadSnapshotHandleWithExecutionContext,
+                  nativeContextHandle,
+                  snapshot,
+                  state.snapshot_id,
+                  context.snapshotKeyBase64,
+                  context.snapshotKeyDigest,
+                  state.token,
+                );
+          }
+          loadedProgramHandle = callNative(native.loadProgram, Buffer.from(dumpedProgram));
+          return nativeContextHandle === null
+            ? callNative(
+                native.loadDetachedSnapshotHandle,
+                loadedProgramHandle,
+                snapshot,
+                policyJson,
+              )
+            : callNative(
+                native.loadDetachedSnapshotHandleWithExecutionContext,
+                loadedProgramHandle,
+                nativeContextHandle,
+                snapshot,
+                state.snapshot_id,
+                context.snapshotKeyBase64,
+                context.snapshotKeyDigest,
+                state.token,
+              );
+        };
+        if (suspendedManifest !== null) {
+          assertAuthorizedSuspendedCapability(
+            context.policy,
+            suspendedManifest.capability,
+          );
+          try {
+            snapshotHandle = loadSnapshotHandle();
+          } catch (error) {
+            if (loadedProgramHandle !== null) {
+              try {
+                callNative(native.releaseProgram, loadedProgramHandle);
+              } catch {
+                // Best-effort cleanup only.
+              }
+            }
+            throw error;
+          }
+          return new Progress(
+            snapshot,
+            suspendedManifest.capability,
+            suspendedManifest.args,
+            context.policy,
+            context.snapshotKey,
+            state.token,
+            'claimed',
+            state.suspended_manifest,
+            state.suspended_manifest_token,
+            loadedProgramHandle,
+            dumpedProgram,
+            dumpedProgramId,
+            snapshotHandle,
+            state.snapshot_id,
+            context.snapshotKeyBase64,
+            context.snapshotKeyDigest,
+          );
+        }
+
+        try {
+          snapshotHandle = loadSnapshotHandle();
+          const inspection = parseSnapshotInspection(
+            callNative(native.inspectSnapshotHandle, snapshotHandle),
+          );
+          return new Progress(
+            snapshot,
+            inspection.capability,
+            inspection.args,
+            context.policy,
+            context.snapshotKey,
+            state.token,
+            'claimed',
+            undefined,
+            undefined,
+            loadedProgramHandle,
+            dumpedProgram,
+            dumpedProgramId,
+            snapshotHandle,
+            state.snapshot_id,
+            context.snapshotKeyBase64,
+            context.snapshotKeyDigest,
+          );
+        } catch (error) {
+          if (snapshotHandle !== null) {
+            try {
+              callNative(native.releaseSnapshotHandle, snapshotHandle);
+            } catch {
+              // Best-effort cleanup only.
+            }
+          }
+          if (loadedProgramHandle !== null) {
+            try {
+              callNative(native.releaseProgram, loadedProgramHandle);
+            } catch {
+              // Best-effort cleanup only.
+            }
+          }
+          throw error;
+        }
       } catch (error) {
         releaseClaim();
         throw error;
@@ -325,7 +686,14 @@ function createProgressApi(native) {
       type: 'suspended',
       capability: step.capability,
       args: step.args.map(decodeStructured),
-      snapshot: Buffer.from(step.snapshot_base64, 'base64'),
+      snapshot:
+        typeof step.snapshot_base64 === 'string'
+          ? Buffer.from(step.snapshot_base64, 'base64')
+          : null,
+      snapshotHandle:
+        typeof step.snapshot_handle === 'string' && step.snapshot_handle.length > 0
+          ? step.snapshot_handle
+          : null,
     };
   }
 
@@ -337,11 +705,29 @@ function createProgressApi(native) {
     };
   }
 
-  function materializeStep(step, policy, snapshotKey) {
+  function materializeStep(step, policy, snapshotKey, programHandle = null, program = undefined) {
     if (step.type === 'completed') {
       return step.value;
     }
-    return new Progress(step.snapshot, step.capability, step.args, policy, snapshotKey);
+    let ownedProgramHandle = null;
+    if (typeof programHandle === 'string' && programHandle.length > 0) {
+      ownedProgramHandle = callNative(native.retainProgram, programHandle);
+    }
+    return new Progress(
+      step.snapshot,
+      step.capability,
+      step.args,
+      policy,
+      snapshotKey,
+      undefined,
+      'unclaimed',
+      undefined,
+      undefined,
+      ownedProgramHandle,
+      program,
+      undefined,
+      step.snapshotHandle,
+    );
   }
 
   return {