rightsize 0.7.9 → 0.7.12

package/dist/backend-msb/sandbox-already-exists.d.ts

@@ -0,0 +1,32 @@
+/**
+ * True if `output` (an `msb restore` invocation's combined stdout/stderr)
+ * names msb's own sandbox-name collision refusal — msb refuses to create a
+ * second sandbox under a name it already has one for. Captured shape:
+ *
+ * ```text
+ * error: sandbox 'rz-abc-1' already exists
+ * ```
+ *
+ * EMPIRICALLY VERIFIED against msb 0.7.1's own source
+ * (`prepare_create_target` in `sdk/rust/lib/backend/local/sandbox/create.rs`):
+ * the check is `existing.is_some() || dir_exists` — the refusal fires when
+ * EITHER the sandbox's database record still exists OR its on-disk directory
+ * does, two independent things that can each still be mid-release on
+ * Windows. `MsbCliBackend.createCheckpoint`'s own stop/snapshot/`rm`/restore
+ * cycle removes the source sandbox and immediately restores a fresh one
+ * under the SAME name, so a lingering release on either side races the very
+ * next `restore` straight into this refusal.
+ *
+ * Deliberately a broad, case-insensitive substring match (mirrors this
+ * backend's own `isPortBindConflictOutput`, and the sibling classifiers this
+ * whole family of msb backends — rust, kotlin — use for the identical
+ * signature) rather than a strict parse: msb has no structured/typed error
+ * for this, only combined process output, and a collision can be worded
+ * around either the sandbox's name or (rarely, alternate msb builds) its
+ * dedicated "already in use" phrasing. Only ever checked against a
+ * `msb restore` invocation's own output — a `msb snapshot load` "already
+ * exists" (see `isSnapshotAlreadyExistsError`) is a completely different
+ * command and never appears here.
+ */
+export declare function isSandboxAlreadyExistsFailure(output: string): boolean;
+//# sourceMappingURL=sandbox-already-exists.d.ts.map

package/dist/backend-msb/sandbox-already-exists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox-already-exists.d.ts","sourceRoot":"","sources":["../../src/backend-msb/sandbox-already-exists.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAGrE"}

package/dist/backend-msb/sandbox-already-exists.js

@@ -0,0 +1,35 @@
+/**
+ * True if `output` (an `msb restore` invocation's combined stdout/stderr)
+ * names msb's own sandbox-name collision refusal — msb refuses to create a
+ * second sandbox under a name it already has one for. Captured shape:
+ *
+ * ```text
+ * error: sandbox 'rz-abc-1' already exists
+ * ```
+ *
+ * EMPIRICALLY VERIFIED against msb 0.7.1's own source
+ * (`prepare_create_target` in `sdk/rust/lib/backend/local/sandbox/create.rs`):
+ * the check is `existing.is_some() || dir_exists` — the refusal fires when
+ * EITHER the sandbox's database record still exists OR its on-disk directory
+ * does, two independent things that can each still be mid-release on
+ * Windows. `MsbCliBackend.createCheckpoint`'s own stop/snapshot/`rm`/restore
+ * cycle removes the source sandbox and immediately restores a fresh one
+ * under the SAME name, so a lingering release on either side races the very
+ * next `restore` straight into this refusal.
+ *
+ * Deliberately a broad, case-insensitive substring match (mirrors this
+ * backend's own `isPortBindConflictOutput`, and the sibling classifiers this
+ * whole family of msb backends — rust, kotlin — use for the identical
+ * signature) rather than a strict parse: msb has no structured/typed error
+ * for this, only combined process output, and a collision can be worded
+ * around either the sandbox's name or (rarely, alternate msb builds) its
+ * dedicated "already in use" phrasing. Only ever checked against a
+ * `msb restore` invocation's own output — a `msb snapshot load` "already
+ * exists" (see `isSnapshotAlreadyExistsError`) is a completely different
+ * command and never appears here.
+ */
+export function isSandboxAlreadyExistsFailure(output) {
+    const m = output.toLowerCase();
+    return m.includes("already exists") || (m.includes("already in use") && m.includes("name"));
+}
+//# sourceMappingURL=sandbox-already-exists.js.map

package/dist/backend-msb/sandbox-already-exists.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox-already-exists.js","sourceRoot":"","sources":["../../src/backend-msb/sandbox-already-exists.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,6BAA6B,CAAC,MAAc;IAC1D,MAAM,CAAC,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC;IAC/B,OAAO,CAAC,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;AAC9F,CAAC"}

package/dist/backend-msb/snapshot-create.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Extracts the artifact path msb prints as the LAST line of a successful
+ * `msb snapshot create --from-sandbox ...` invocation's stdout. EMPIRICALLY
+ * VERIFIED against a real msb 0.7.1 binary: the command prints the snapshot
+ * ID line first, then the absolute artifact path as its final line —
+ * `<destDir-or-default>/<sourceSandbox>/snap_<32-hex-digest>` (see
+ * `MsbCommands.snapshotCreate`'s own doc for why the caller-supplied name
+ * never determines this path). `MsbCliBackend.createCheckpoint` uses the
+ * returned path — never the ref it asked msb to create the snapshot under —
+ * as the effective checkpoint ref for every later restore/rm/inspect call.
+ *
+ * Deliberately conservative, matching the HARD CONSTRAINT this parser was
+ * written to satisfy: trims the whole output, keeps only non-empty lines,
+ * takes the LAST one, and requires it to be an absolute path (`path.isAbsolute`)
+ * — anything else (empty output, a relative-looking last line, some future
+ * extra trailing line this parser has never seen) resolves `undefined`
+ * rather than guessing, so the caller can fail loudly with the raw,
+ * unparsed output quoted verbatim instead of minting a checkpoint ref from a
+ * misread line.
+ */
+export declare function parseSnapshotCreateArtifactPath(stdout: string): string | undefined;
+//# sourceMappingURL=snapshot-create.d.ts.map

package/dist/backend-msb/snapshot-create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-create.d.ts","sourceRoot":"","sources":["../../src/backend-msb/snapshot-create.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAUlF"}

package/dist/backend-msb/snapshot-create.js

@@ -0,0 +1,33 @@
+import * as path from "node:path";
+/**
+ * Extracts the artifact path msb prints as the LAST line of a successful
+ * `msb snapshot create --from-sandbox ...` invocation's stdout. EMPIRICALLY
+ * VERIFIED against a real msb 0.7.1 binary: the command prints the snapshot
+ * ID line first, then the absolute artifact path as its final line —
+ * `<destDir-or-default>/<sourceSandbox>/snap_<32-hex-digest>` (see
+ * `MsbCommands.snapshotCreate`'s own doc for why the caller-supplied name
+ * never determines this path). `MsbCliBackend.createCheckpoint` uses the
+ * returned path — never the ref it asked msb to create the snapshot under —
+ * as the effective checkpoint ref for every later restore/rm/inspect call.
+ *
+ * Deliberately conservative, matching the HARD CONSTRAINT this parser was
+ * written to satisfy: trims the whole output, keeps only non-empty lines,
+ * takes the LAST one, and requires it to be an absolute path (`path.isAbsolute`)
+ * — anything else (empty output, a relative-looking last line, some future
+ * extra trailing line this parser has never seen) resolves `undefined`
+ * rather than guessing, so the caller can fail loudly with the raw,
+ * unparsed output quoted verbatim instead of minting a checkpoint ref from a
+ * misread line.
+ */
+export function parseSnapshotCreateArtifactPath(stdout) {
+    const lines = stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const lastLine = lines.at(-1);
+    if (lastLine === undefined || !path.isAbsolute(lastLine)) {
+        return undefined;
+    }
+    return lastLine;
+}
+//# sourceMappingURL=snapshot-create.js.map

package/dist/backend-msb/snapshot-create.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-create.js","sourceRoot":"","sources":["../../src/backend-msb/snapshot-create.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,+BAA+B,CAAC,MAAc;IAC5D,MAAM,KAAK,GAAG,MAAM;SACjB,KAAK,CAAC,IAAI,CAAC;SACX,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;SAC1B,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACrC,MAAM,QAAQ,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9B,IAAI,QAAQ,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzD,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/backend-msb/snapshot-import.d.ts

@@ -12,22 +12,38 @@
  * one rather than surfacing it. Deliberately a substring match on the stable
  * prefix, the same reasoning `isSnapshotNotFoundError` applies to its own
  * wording: the trailing path varies per host and msb has no structured/typed
- * error for this.
+ * error for this. Not re-verified against 0.7.1 specifically (the rename to
+ * `save`/`load` did not touch this message in any captured output), so this
+ * stays a defensive fallback rather than the primary success path.
  */
 export declare function isSnapshotAlreadyExistsError(stderr: string): boolean;
 /**
- * Extracts the digest-dir basename from one `msb snapshot load`
- * invocation's output. Verified against the real msb 0.6.8 binary: on both a
- * success (the printed stdout line) and an already-exists failure (the
- * `error: snapshot already exists: <path>` stderr line), the relevant line
- * ENDS with the artifact path under `~/.microsandbox/snapshots/`, whose
- * basename is the digest-derived directory name (e.g.
- * `sha256-b9c0448ee9d54e33`) — never the original archive's own recorded
- * ref. Callers pass whichever stream actually carries the signal (stdout on
- * success, stderr on an already-exists failure). `undefined` means the
- * output carried no recognizable trailing path — a shape this backend
- * doesn't understand, which the caller turns into its own actionable error
- * rather than guessing.
+ * Extracts the loaded artifact's absolute path from one `msb snapshot load`
+ * invocation's output — the EFFECTIVE ref `importCheckpoint` hands back.
+ * EMPIRICALLY VERIFIED against a real msb 0.7.1 binary: a successful load
+ * prints a `group msb-<hex>: head snap_<digest> (Initialized)` line, then a
+ * digest line, then the loaded artifact's absolute path as the LAST line —
+ * `<destDir>/<generated-group>/snap_<digest>`, where `<destDir>` is whatever
+ * `--dest` was given (see `MsbCommands.snapshotImport`). The same defensive
+ * pattern `parseSnapshotCreateArtifactPath` uses for `snapshot create`'s own
+ * trailing-path output: trims the whole output, keeps only non-empty lines,
+ * takes the LAST one, and requires it to be an absolute path — anything else
+ * (empty output, a relative-looking last line, msb's own preceding "group"/
+ * digest lines mistaken for the answer) resolves `undefined` rather than
+ * guessing, so the caller fails loudly with the raw output quoted verbatim
+ * instead of minting a checkpoint ref from a misread line. This replaces the
+ * pre-0.7.1 approach of parsing out just the digest-dir BASENAME and then
+ * confirming it via a separate `msb snapshot list` call — 0.7.1's `load`
+ * already prints the full, directly-usable ref, so that second call is gone.
+ *
+ * The already-exists failure path (see `isSnapshotAlreadyExistsError`) has a
+ * different last-line shape than a success's: msb's own message prefixes
+ * the path with prose on the SAME line (`error: snapshot already exists:
+ * <path>`), captured verbatim from the real 0.6.8 binary and not
+ * re-verified against 0.7.1 — so a whole-line match never fires for it.
+ * When the whole line isn't itself an absolute path, this falls back to the
+ * line's trailing whitespace-delimited token and requires THAT to be
+ * absolute instead, rather than guessing a ref out of prose.
  */
-export declare function parseImportedDigestDirName(output: string): string | undefined;
+export declare function parseImportedArtifactPath(output: string): string | undefined;
 //# sourceMappingURL=snapshot-import.d.ts.map

package/dist/backend-msb/snapshot-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"snapshot-import.d.ts","sourceRoot":"","sources":["../../src/backend-msb/snapshot-import.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEpE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAY7E"}
+{"version":3,"file":"snapshot-import.d.ts","sourceRoot":"","sources":["../../src/backend-msb/snapshot-import.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEpE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAc5E"}

package/dist/backend-msb/snapshot-import.js

@@ -13,26 +13,42 @@ import * as path from "node:path";
  * one rather than surfacing it. Deliberately a substring match on the stable
  * prefix, the same reasoning `isSnapshotNotFoundError` applies to its own
  * wording: the trailing path varies per host and msb has no structured/typed
- * error for this.
+ * error for this. Not re-verified against 0.7.1 specifically (the rename to
+ * `save`/`load` did not touch this message in any captured output), so this
+ * stays a defensive fallback rather than the primary success path.
  */
 export function isSnapshotAlreadyExistsError(stderr) {
     return stderr.includes("snapshot already exists");
 }
 /**
- * Extracts the digest-dir basename from one `msb snapshot load`
- * invocation's output. Verified against the real msb 0.6.8 binary: on both a
- * success (the printed stdout line) and an already-exists failure (the
- * `error: snapshot already exists: <path>` stderr line), the relevant line
- * ENDS with the artifact path under `~/.microsandbox/snapshots/`, whose
- * basename is the digest-derived directory name (e.g.
- * `sha256-b9c0448ee9d54e33`) — never the original archive's own recorded
- * ref. Callers pass whichever stream actually carries the signal (stdout on
- * success, stderr on an already-exists failure). `undefined` means the
- * output carried no recognizable trailing path — a shape this backend
- * doesn't understand, which the caller turns into its own actionable error
- * rather than guessing.
+ * Extracts the loaded artifact's absolute path from one `msb snapshot load`
+ * invocation's output — the EFFECTIVE ref `importCheckpoint` hands back.
+ * EMPIRICALLY VERIFIED against a real msb 0.7.1 binary: a successful load
+ * prints a `group msb-<hex>: head snap_<digest> (Initialized)` line, then a
+ * digest line, then the loaded artifact's absolute path as the LAST line —
+ * `<destDir>/<generated-group>/snap_<digest>`, where `<destDir>` is whatever
+ * `--dest` was given (see `MsbCommands.snapshotImport`). The same defensive
+ * pattern `parseSnapshotCreateArtifactPath` uses for `snapshot create`'s own
+ * trailing-path output: trims the whole output, keeps only non-empty lines,
+ * takes the LAST one, and requires it to be an absolute path — anything else
+ * (empty output, a relative-looking last line, msb's own preceding "group"/
+ * digest lines mistaken for the answer) resolves `undefined` rather than
+ * guessing, so the caller fails loudly with the raw output quoted verbatim
+ * instead of minting a checkpoint ref from a misread line. This replaces the
+ * pre-0.7.1 approach of parsing out just the digest-dir BASENAME and then
+ * confirming it via a separate `msb snapshot list` call — 0.7.1's `load`
+ * already prints the full, directly-usable ref, so that second call is gone.
+ *
+ * The already-exists failure path (see `isSnapshotAlreadyExistsError`) has a
+ * different last-line shape than a success's: msb's own message prefixes
+ * the path with prose on the SAME line (`error: snapshot already exists:
+ * <path>`), captured verbatim from the real 0.6.8 binary and not
+ * re-verified against 0.7.1 — so a whole-line match never fires for it.
+ * When the whole line isn't itself an absolute path, this falls back to the
+ * line's trailing whitespace-delimited token and requires THAT to be
+ * absolute instead, rather than guessing a ref out of prose.
  */
-export function parseImportedDigestDirName(output) {
+export function parseImportedArtifactPath(output) {
     const lines = output
         .split("\n")
         .map((line) => line.trim())
@@ -41,8 +57,10 @@ export function parseImportedDigestDirName(output) {
     if (lastLine === undefined) {
         return undefined;
     }
-    const match = /(\S+)\s*$/.exec(lastLine);
-    const artifactPath = match?.[1];
-    return artifactPath === undefined ? undefined : path.basename(artifactPath);
+    if (path.isAbsolute(lastLine)) {
+        return lastLine;
+    }
+    const trailingToken = /(\S+)\s*$/.exec(lastLine)?.[1];
+    return trailingToken !== undefined && path.isAbsolute(trailingToken) ? trailingToken : undefined;
 }
 //# sourceMappingURL=snapshot-import.js.map

package/dist/backend-msb/snapshot-import.js.map

@@ -1 +1 @@
-{"version":3,"file":"snapshot-import.js","sourceRoot":"","sources":["../../src/backend-msb/snapshot-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,4BAA4B,CAAC,MAAc;IACzD,OAAO,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAAC,CAAC;AACpD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,0BAA0B,CAAC,MAAc;IACvD,MAAM,KAAK,GAAG,MAAM;SACjB,KAAK,CAAC,IAAI,CAAC;SACX,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;SAC1B,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACrC,MAAM,QAAQ,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9B,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACzC,MAAM,YAAY,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;IAChC,OAAO,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;AAC9E,CAAC"}
+{"version":3,"file":"snapshot-import.js","sourceRoot":"","sources":["../../src/backend-msb/snapshot-import.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,4BAA4B,CAAC,MAAc;IACzD,OAAO,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAAC,CAAC;AACpD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,yBAAyB,CAAC,MAAc;IACtD,MAAM,KAAK,GAAG,MAAM;SACjB,KAAK,CAAC,IAAI,CAAC;SACX,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;SAC1B,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACrC,MAAM,QAAQ,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9B,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC9B,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,MAAM,aAAa,GAAG,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACtD,OAAO,aAAa,KAAK,SAAS,IAAI,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC;AACnG,CAAC"}

package/dist/backend-msb/snapshot-rm.d.ts

@@ -0,0 +1,28 @@
+/**
+ * True if `stderr` (an `msb snapshot rm <artifact-path> -f` non-zero exit)
+ * names msb's own "this snapshot is the current head of other snapshots
+ * from the same source sandbox" refusal, as opposed to a genuine "not
+ * found" (which `removeCheckpoint` treats as success, the same best-effort
+ * contract `removeByName` has) or some other, unrelated failure.
+ * EMPIRICALLY VERIFIED against a real msb 0.7.1 binary:
+ *
+ * ```
+ * error: invalid config: cannot remove current head snap_<digest>; first
+ * select another snapshot with 'msb snapshot head src:<snapshot>'
+ * ```
+ *
+ * Removing a non-head member, or a group's ONLY member, succeeds — this
+ * refusal is specifically "older siblings from the same source sandbox
+ * still exist and this is still the newest of them." `removeCheckpoint`
+ * propagates this one verbatim instead of swallowing it alongside an
+ * ordinary "not found": the caller has an actionable remedy (`msb snapshot
+ * head ...`, named in msb's own message), and this library deliberately
+ * does not attempt automatic head rotation on the caller's behalf — see the
+ * checkpoints guide's cleanup section for the documented limitation.
+ * Deliberately a substring match on the stable "cannot remove current head"
+ * phrase, the same reasoning `isSnapshotNotFoundError` applies to its own
+ * wording — the snapshot id and the exact command hint vary per occurrence,
+ * and msb has no structured/typed error for this.
+ */
+export declare function isSnapshotHeadRemovalRefused(stderr: string): boolean;
+//# sourceMappingURL=snapshot-rm.d.ts.map

package/dist/backend-msb/snapshot-rm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-rm.d.ts","sourceRoot":"","sources":["../../src/backend-msb/snapshot-rm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEpE"}

package/dist/backend-msb/snapshot-rm.js

@@ -0,0 +1,30 @@
+/**
+ * True if `stderr` (an `msb snapshot rm <artifact-path> -f` non-zero exit)
+ * names msb's own "this snapshot is the current head of other snapshots
+ * from the same source sandbox" refusal, as opposed to a genuine "not
+ * found" (which `removeCheckpoint` treats as success, the same best-effort
+ * contract `removeByName` has) or some other, unrelated failure.
+ * EMPIRICALLY VERIFIED against a real msb 0.7.1 binary:
+ *
+ * ```
+ * error: invalid config: cannot remove current head snap_<digest>; first
+ * select another snapshot with 'msb snapshot head src:<snapshot>'
+ * ```
+ *
+ * Removing a non-head member, or a group's ONLY member, succeeds — this
+ * refusal is specifically "older siblings from the same source sandbox
+ * still exist and this is still the newest of them." `removeCheckpoint`
+ * propagates this one verbatim instead of swallowing it alongside an
+ * ordinary "not found": the caller has an actionable remedy (`msb snapshot
+ * head ...`, named in msb's own message), and this library deliberately
+ * does not attempt automatic head rotation on the caller's behalf — see the
+ * checkpoints guide's cleanup section for the documented limitation.
+ * Deliberately a substring match on the stable "cannot remove current head"
+ * phrase, the same reasoning `isSnapshotNotFoundError` applies to its own
+ * wording — the snapshot id and the exact command hint vary per occurrence,
+ * and msb has no structured/typed error for this.
+ */
+export function isSnapshotHeadRemovalRefused(stderr) {
+    return stderr.includes("cannot remove current head");
+}
+//# sourceMappingURL=snapshot-rm.js.map

package/dist/backend-msb/snapshot-rm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-rm.js","sourceRoot":"","sources":["../../src/backend-msb/snapshot-rm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,4BAA4B,CAAC,MAAc;IACzD,OAAO,MAAM,CAAC,QAAQ,CAAC,4BAA4B,CAAC,CAAC;AACvD,CAAC"}

package/dist/core/backend.d.ts

@@ -1,4 +1,4 @@
-import type { ContainerSpec, ExecResult } from "./model.js";
+import type { ContainerSpec, ExecResult, PortProtocol } from "./model.js";
 /**
  * One alias a container should be reachable under from a running sibling on
  * the same `Network`, computed by `Network.linksForNewMember()`. A native
@@ -12,6 +12,20 @@ export interface NetworkLink {
     readonly guestPort: number;
     /** The sibling's host-side mapped port to tunnel/route traffic to. */
     readonly targetHostPort: number;
+    /**
+     * The transport `guestPort` was exposed over. `"tcp"` for every link
+     * computed from a sibling's `exposedGuestPorts`/`mappedPort` (unchanged
+     * behavior); `"udp"` for one computed from `exposedUdpGuestPorts`/
+     * `mappedUdpPort`. Docker ignores this — its native bridge network already
+     * carries UDP with no per-link declaration (see `installNetworkLinks`'s
+     * own doc); msb has no shared network to carry either transport, so it
+     * emulates both, but by different means: a TCP link gets an exec-tunnel
+     * relayed through this process (`MsbCliBackend`'s `ExecTunnel`), a UDP
+     * link gets an in-guest forwarder dialing `targetHostPort` on the host
+     * gateway directly, with no per-connection relay on this side at all (see
+     * `MsbCliBackend.installNetworkLinks`).
+     */
+    readonly protocol: PortProtocol;
 }
 /**
  * Backend-native opaque container reference. Immutable id + spec; any
@@ -100,19 +114,49 @@ export interface SandboxBackend {
     /** Best-effort removal of the backend-native resource; callers swallow failures during teardown. */
     remove(handle: SandboxHandle): Promise<void>;
     /**
-     * Captures `handle`'s current state under `ref` —
-     * `GenericContainer.checkpoint()`'s backend call, gated on
+     * Captures `handle`'s current state and returns the EFFECTIVE ref to use
+     * from here on — `GenericContainer.checkpoint()`'s backend call, gated on
      * `capabilities.checkpoint` BEFORE this is ever reached, so an
      * unsupported backend never has to implement this for real (it may throw
-     * defensively). Docker: commits the running container to image `ref`,
-     * undisturbed. Microsandbox: stop the sandbox, `msb snapshot create` a
-     * disk snapshot under `ref` (an absolute `<cacheDir>/checkpoints/rz-ckpt-*`
-     * path — via `--dest-dir`, not msb's own default snapshot store), then
-     * start the sandbox back up — the workload restarts, which is why
-     * `capabilities.checkpointRestartsWorkload` exists. Never called on a
-     * backend whose `capabilities.checkpoint` is `false`.
+     * defensively). `ref` is the WORKING ref the caller asks this to
+     * checkpoint under; the returned value is not necessarily `ref` itself —
+     * the same asymmetry `importCheckpoint` already has, for the same reason.
+     * Docker: commits the running container to image `ref`, undisturbed, and
+     * returns `ref` unchanged (docker's tag round-trips exactly). Microsandbox:
+     * stop the sandbox, `msb snapshot create` a disk snapshot (via `--dest-dir`,
+     * not msb's own default snapshot store), then start the sandbox back up —
+     * the workload restarts, which is why `capabilities.checkpointRestartsWorkload`
+     * exists. Since msb 0.7.1, `snapshot create`'s own artifact placement is
+     * content-addressed and `ref` never determines it (see `MsbCliBackend`'s
+     * own doc), so the microsandbox backend parses the real artifact path back
+     * out of that command's stdout and returns THAT as the effective ref — the
+     * caller (`GenericContainer.checkpoint()`) stores whatever this returns in
+     * the named-checkpoint registry and on the `Checkpoint` it hands back,
+     * never `ref` itself. Never called on a backend whose
+     * `capabilities.checkpoint` is `false`.
+     */
+    createCheckpoint(handle: SandboxHandle, ref: string): Promise<string>;
+    /**
+     * OPTIONAL: the workload argv this backend captured from `handle`'s guest
+     * during its MOST RECENT `createCheckpoint` call, when that call's source
+     * container had no explicit `spec.command` — `undefined` when nothing was
+     * captured (an explicit command needed no capture, the capture attempt
+     * itself failed, or this backend never captures at all). `createCheckpoint`
+     * itself never surfaces this — it stays `Promise<string>`, unchanged — so
+     * `GenericContainer.checkpoint()` calls this SEPARATELY, right after
+     * `createCheckpoint` returns, to fold the result into a NAMED checkpoint's
+     * registry entry (`CheckpointRegistryEntry.capturedCommand`) and into the
+     * `Checkpoint.spec.command` it hands back, so a later restore — registry-
+     * mediated or not — has the fully-resolved workload argv without a second
+     * capture attempt against a sandbox that (on msb) no longer even runs the
+     * old one. A backend that never captures (docker: restoring a checkpoint
+     * is an ordinary boot from the committed image, whose own baked
+     * ENTRYPOINT/CMD already reproduces the workload with no capture needed)
+     * simply omits this method — every existing implementation keeps compiling
+     * and behaving unchanged. See `MsbCliBackend.createCheckpoint`'s own doc
+     * for when and how the microsandbox backend actually captures one.
      */
-    createCheckpoint(handle: SandboxHandle, ref: string): Promise<void>;
+    capturedWorkloadCommand?(handle: SandboxHandle): ReadonlyArray<string> | undefined;
     /**
      * Best-effort removal of a checkpoint identified by `ref` (docker: `rmi`;
      * microsandbox: `msb snapshot rm`) — "not found" is success, the same
@@ -155,18 +199,19 @@ export interface SandboxBackend {
      * Materializes an exported archive's backend payload from `srcFile` and
      * returns the EFFECTIVE ref to use from here on — not necessarily `ref`
      * itself. docker preserves the original tag on `docker load`, so its
-     * effective ref IS `ref`; microsandbox's `snapshot load` writes under a
-     * digest-derived DIRECTORY NAME (e.g. `sha256-b9c0448ee9d54e33`) it never
-     * lets the caller choose, so its effective ref is that directory name,
-     * confirmed present via `snapshot list --format json` — never the full
-     * `sha256:<64hex>` digest, which does not resolve as a snapshot ref at
-     * all. An already-exists failure for a content-addressed archive is
-     * treated as success. `ref` is the archive's own recorded ref (from
-     * `checkpoint.json`), passed through for backends (docker) that have no
-     * new ref to derive. Only ever called once the generic layer has already
-     * validated the archive's `checkpoint.json` (version, name, backend)
-     * against the active backend; any failure other than "already imported"
-     * surfaces the underlying tool's stderr in a `BackendError`.
+     * effective ref IS `ref`; microsandbox's `snapshot load --dest
+     * <checkpointsDir>` writes under a path msb itself generates (never the
+     * caller's `ref`, never a name the caller can choose), which this backend
+     * parses straight out of `load`'s own printed output — no separate
+     * confirmation call needed, since 0.7.1 already prints the full, directly
+     * usable path (see `MsbCliBackend.importCheckpoint`). An already-exists
+     * failure for a content-addressed archive is treated as success. `ref` is
+     * the archive's own recorded ref (from `checkpoint.json`), passed through
+     * for backends (docker) that have no new ref to derive. Only ever called
+     * once the generic layer has already validated the archive's
+     * `checkpoint.json` (version, name, backend) against the active backend;
+     * any failure other than "already imported" surfaces the underlying
+     * tool's stderr in a `BackendError`.
      */
     importCheckpoint(srcFile: string, ref: string): Promise<string>;
     /**

package/dist/core/backend.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../src/core/backend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,sDAAsD;IACtD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,sEAAsE;IACtE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;CAC9B;AAED,2FAA2F;AAC3F,MAAM,WAAW,YAAY;IAC3B,+HAA+H;IAC/H,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB;IAChC,0HAA0H;IAC1H,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACrC,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACvC,kJAAkJ;IAClJ,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC/C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B;;;;;;;;OAQG;IACH,QAAQ,CAAC,0BAA0B,EAAE,OAAO,CAAC;CAC9C;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0HAA0H;IAC1H,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;IACzC,wFAAwF;IACxF,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,8GAA8G;IAC9G,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACpD,iKAAiK;IACjK,KAAK,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,kEAAkE;IAClE,IAAI,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,oGAAoG;IACpG,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE;;;;;;OAMG;IACH,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C;;;;;;;;;;;;;;;;;OAiBG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7C;;;;;;;;;OASG;IACH,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/D;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAChE;;;;;;;OAOG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C;;;;;;;;;OASG;IACH,WAAW,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAAC;IACrE,gGAAgG;IAChG,iBAAiB,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAChD,iFAAiF;IACjF,IAAI,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC7E,0EAA0E;IAC1E,IAAI,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7C;;;;;OAKG;IACH,UAAU,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IAC3F,yDAAyD;IACzD,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,mEAAmE;IACnE,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,+FAA+F;IAC/F,mBAAmB,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7F;;;;;;;;;;OAUG;IACH,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/F,qJAAqJ;IACrJ,iBAAiB,CAAC,MAAM,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjG,kFAAkF;IAClF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,2FAA2F;IAC3F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,2HAA2H;IAC3H,WAAW,IAAI,OAAO,CAAC;IACvB,8GAA8G;IAC9G,iBAAiB,IAAI,MAAM,CAAC;IAC5B,8EAA8E;IAC9E,MAAM,IAAI,cAAc,CAAC;CAC1B"}
+{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../src/core/backend.ts"],"names":[],"mappings":"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"}

package/dist/core/checkpoint/api.d.ts

@@ -91,8 +91,8 @@ export declare function exportTo(cp: Checkpoint, destPath: string): Promise<void
  * either way, before any backend call or registry write), then hands the
  * extracted `artifact` to `SandboxBackend.importCheckpoint`, which
  * materializes it and returns the EFFECTIVE ref (docker: the same `ref` the
- * archive recorded; microsandbox: the digest `snapshot load` actually
- * assigned it — never necessarily the archive's own `ref`).
+ * archive recorded; microsandbox: the loaded artifact's own path `snapshot
+ * load` actually assigned it — never necessarily the archive's own `ref`).
  *
  * A NAMED archive (`name` non-null) gets replace semantics matching
  * `checkpoint(name)`: if a registry entry already exists for that name under

package/dist/core/checkpoint/api.js

@@ -189,8 +189,8 @@ export async function exportTo(cp, destPath) {
  * either way, before any backend call or registry write), then hands the
  * extracted `artifact` to `SandboxBackend.importCheckpoint`, which
  * materializes it and returns the EFFECTIVE ref (docker: the same `ref` the
- * archive recorded; microsandbox: the digest `snapshot load` actually
- * assigned it — never necessarily the archive's own `ref`).
+ * archive recorded; microsandbox: the loaded artifact's own path `snapshot
+ * load` actually assigned it — never necessarily the archive's own `ref`).
  *
  * A NAMED archive (`name` non-null) gets replace semantics matching
  * `checkpoint(name)`: if a registry entry already exists for that name under

package/dist/core/checkpoint/registry.d.ts

@@ -12,8 +12,20 @@ import type { ContainerSpec } from "../model.js";
 export interface CheckpointRegistrySpec {
     readonly env: Record<string, string>;
     readonly command: ReadonlyArray<string> | null;
+    /** TCP-exposed guest ports only — unchanged shape/name from before UDP exposure existed. */
     readonly exposedPorts: ReadonlyArray<number>;
     readonly memoryLimitMb: number | null;
+    /**
+     * UDP-exposed guest ports (`withExposedUdpPorts`), kept as a SEPARATE list
+     * from `exposedPorts` so a restore can split them back into the right
+     * builder field (`fromCheckpoint` calls `withExposedPorts` for one list and
+     * `withExposedUdpPorts` for the other) rather than guessing protocol from a
+     * merged list of bare numbers. ADDITIVE and OPTIONAL: absent on every entry
+     * written before UDP exposure existed — a deserializer/validator reading an
+     * old entry treats a missing value as "no UDP ports were ever exposed"
+     * (normalizes to `[]`), never as corrupt.
+     */
+    readonly exposedUdpPorts?: ReadonlyArray<number>;
 }
 /**
  * One `checkpoints/<name>.json` record: written atomically only after the
@@ -30,6 +42,28 @@ export interface CheckpointRegistryEntry {
     readonly backend: string;
     readonly createdIso: string;
     readonly spec: CheckpointRegistrySpec;
+    /**
+     * The workload argv `GenericContainer.checkpoint()` captured from the
+     * guest at checkpoint time (via `SandboxBackend.capturedWorkloadCommand`),
+     * for a source container whose own `spec.command` was `undefined` — the
+     * image's default entrypoint was running, so there is no explicit command
+     * to fall back on at restore time. msb-only in practice today: `msb
+     * restore` boots a restored sandbox with only its guest agent inside and
+     * never re-runs a captured workload on its own (EMPIRICALLY VERIFIED
+     * against msb 0.7.1 — see `MsbCliBackend.bootRestoreOnce`'s own doc), so
+     * this library restarts it itself, using this field as the argv source
+     * when the checkpoint carries no explicit `spec.command`.
+     *
+     * ADDITIVE and OPTIONAL — deliberately NOT part of the pinned, cross-
+     * language `CheckpointRegistrySpec` shape `spec` above carries: absent on
+     * every entry written before this field existed, and on any entry whose
+     * source container already had an explicit `spec.command` (nothing to
+     * capture). Reading an old entry without it is not an error — only
+     * restoring FROM one, when the entry also has no explicit `spec.command`,
+     * throws `CheckpointWorkloadCommandMissingError` rather than booting a
+     * workload-less sandbox silently (see `fromCheckpointRegistryEntry` below).
+     */
+    readonly capturedCommand?: ReadonlyArray<string>;
 }
 /** `<cacheDir>/checkpoints` — the directory every named checkpoint's registry file lives under. */
 export declare function checkpointsDir(cacheDir: string): string;
@@ -106,6 +140,18 @@ export declare function toCheckpointRegistrySpec(spec: ContainerSpec): Checkpoin
  * pointing at itself. `diskLimitMb`/`tmpfsRootMb`/`networkDisabled` are
  * placeholders too — the registry's pinned `CheckpointRegistrySpec` shape
  * doesn't carry them, same as it never carried `keepAlive`.
+ *
+ * `command` resolves with `entry.capturedCommand` as its fallback: when the
+ * source container had an explicit command, `entry.spec.command` already
+ * carries it and `capturedCommand` (never set for that case) never enters
+ * into it; when it did not, this substitutes whatever guest cmdline
+ * `checkpoint()` captured, so the restored `ContainerSpec`'s `command` is
+ * already the fully-resolved workload argv a restore-side backend (msb)
+ * needs to revive it, with no separate lookup needed at restore time. When
+ * NEITHER is present (an entry written before capture existed, or one whose
+ * capture attempt itself failed), `command` stays `undefined` exactly as
+ * before, and it is the restoring backend's own job to refuse rather than
+ * boot that sandbox silently idle (see `MsbCliBackend.bootRestoreOnce`).
  */
 export declare function fromCheckpointRegistryEntry(entry: CheckpointRegistryEntry): ContainerSpec;
 //# sourceMappingURL=registry.d.ts.map

package/dist/core/checkpoint/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/core/checkpoint/registry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD;;;;;;;;;GASG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IAC/C,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC7C,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,mLAAmL;IACnL,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;CACvC;AAED,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAG7E;AAED,wKAAwK;AACxK,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,sBAAsB,CA8BxF;AAkBD,sLAAsL;AACtL,MAAM,MAAM,4BAA4B,GACpC;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,uBAAuB,CAAA;CAAE,CAAC;AAExE;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAkBlH;AAED;;;;;;;GAOG;AACH,wBAAsB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOjI;AAED,4FAA4F;AAC5F,wBAAsB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhG;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAQ7E;AAOD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,aAAa,GAAG,sBAAsB,CAWpF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,uBAAuB,GAAG,aAAa,CAkBzF"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/core/checkpoint/registry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD;;;;;;;;;GASG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IAC/C,4FAA4F;IAC5F,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC7C,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC;;;;;;;;;OASG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAClD;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,mLAAmL;IACnL,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAClD;AAED,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAG7E;AAED,wKAAwK;AACxK,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,sBAAsB,CAuCxF;AAyBD,sLAAsL;AACtL,MAAM,MAAM,4BAA4B,GACpC;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,uBAAuB,CAAA;CAAE,CAAC;AAExE;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAkBlH;AAED;;;;;;;GAOG;AACH,wBAAsB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOjI;AAED,4FAA4F;AAC5F,wBAAsB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhG;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAQ7E;AAOD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,aAAa,GAAG,sBAAsB,CAgBpF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,uBAAuB,GAAG,aAAa,CA2BzF"}