@warmhub/cli 0.108.0 → 0.110.0

package/dist/wh.js

@@ -11910,7 +11910,7 @@ var require_response = __commonJS((exports, module) => {
   var { types } = __require("node:util");
   var textEncoder2 = new TextEncoder("utf-8");
 
-  class Response {
+  class Response2 {
     static error() {
       const responseObject = fromInnerResponse(makeNetworkError(), "immutable");
       return responseObject;
@@ -11966,11 +11966,11 @@ var require_response = __commonJS((exports, module) => {
       initializeResponse(this, init, bodyWithType);
     }
     get type() {
-      webidl.brandCheck(this, Response);
+      webidl.brandCheck(this, Response2);
       return this[kState].type;
     }
     get url() {
-      webidl.brandCheck(this, Response);
+      webidl.brandCheck(this, Response2);
       const urlList = this[kState].urlList;
       const url2 = urlList[urlList.length - 1] ?? null;
       if (url2 === null) {
@@ -11979,35 +11979,35 @@ var require_response = __commonJS((exports, module) => {
       return URLSerializer(url2, true);
     }
     get redirected() {
-      webidl.brandCheck(this, Response);
+      webidl.brandCheck(this, Response2);
       return this[kState].urlList.length > 1;
     }
     get status() {
-      webidl.brandCheck(this, Response);
+      webidl.brandCheck(this, Response2);
       return this[kState].status;
     }
     get ok() {
-      webidl.brandCheck(this, Response);
+      webidl.brandCheck(this, Response2);
       return this[kState].status >= 200 && this[kState].status <= 299;
     }
     get statusText() {
-      webidl.brandCheck(this, Response);
+      webidl.brandCheck(this, Response2);
       return this[kState].statusText;
     }
     get headers() {
-      webidl.brandCheck(this, Response);
+      webidl.brandCheck(this, Response2);
       return this[kHeaders];
     }
     get body() {
-      webidl.brandCheck(this, Response);
+      webidl.brandCheck(this, Response2);
       return this[kState].body ? this[kState].body.stream : null;
     }
     get bodyUsed() {
-      webidl.brandCheck(this, Response);
+      webidl.brandCheck(this, Response2);
       return !!this[kState].body && util.isDisturbed(this[kState].body.stream);
     }
     clone() {
-      webidl.brandCheck(this, Response);
+      webidl.brandCheck(this, Response2);
       if (bodyUnusable(this)) {
         throw webidl.errors.exception({
           header: "Response.clone",
@@ -12039,8 +12039,8 @@ var require_response = __commonJS((exports, module) => {
       return `Response ${nodeUtil.formatWithOptions(options, properties)}`;
     }
   }
-  mixinBody(Response);
-  Object.defineProperties(Response.prototype, {
+  mixinBody(Response2);
+  Object.defineProperties(Response2.prototype, {
     type: kEnumerableProperty,
     url: kEnumerableProperty,
     status: kEnumerableProperty,
@@ -12056,7 +12056,7 @@ var require_response = __commonJS((exports, module) => {
       configurable: true
     }
   });
-  Object.defineProperties(Response, {
+  Object.defineProperties(Response2, {
     json: kEnumerableProperty,
     redirect: kEnumerableProperty,
     error: kEnumerableProperty
@@ -12182,7 +12182,7 @@ var require_response = __commonJS((exports, module) => {
     }
   }
   function fromInnerResponse(innerResponse, guard) {
-    const response = new Response(kConstruct);
+    const response = new Response2(kConstruct);
     response[kState] = innerResponse;
     response[kHeaders] = new Headers2(kConstruct);
     setHeadersList(response[kHeaders], innerResponse.headersList);
@@ -12244,7 +12244,7 @@ var require_response = __commonJS((exports, module) => {
     makeResponse,
     makeAppropriateNetworkError,
     filterResponse,
-    Response,
+    Response: Response2,
     cloneResponse,
     fromInnerResponse
   };
@@ -14688,7 +14688,7 @@ var require_cache = __commonJS((exports, module) => {
   var { urlEquals, getFieldValues } = require_util5();
   var { kEnumerableProperty, isDisturbed } = require_util();
   var { webidl } = require_webidl();
-  var { Response, cloneResponse, fromInnerResponse } = require_response();
+  var { Response: Response2, cloneResponse, fromInnerResponse } = require_response();
   var { Request, fromInnerRequest } = require_request2();
   var { kState } = require_symbols2();
   var { fetching } = require_fetch();
@@ -15178,7 +15178,7 @@ var require_cache = __commonJS((exports, module) => {
       converter: webidl.converters.DOMString
     }
   ]);
-  webidl.converters.Response = webidl.interfaceConverter(Response);
+  webidl.converters.Response = webidl.interfaceConverter(Response2);
   webidl.converters["sequence<RequestInfo>"] = webidl.sequenceConverter(webidl.converters.RequestInfo);
   module.exports = {
     Cache
@@ -17301,7 +17301,7 @@ var require_eventsource_stream = __commonJS((exports, module) => {
   var { Transform } = __require("node:stream");
   var { isASCIINumber, isValidLastEventId } = require_util8();
   var BOM = [239, 187, 191];
-  var LF = 10;
+  var LF3 = 10;
   var CR = 13;
   var COLON = 58;
   var SPACE = 32;
@@ -17374,7 +17374,7 @@ var require_eventsource_stream = __commonJS((exports, module) => {
       while (this.pos < this.buffer.length) {
         if (this.eventEndCheck) {
           if (this.crlfCheck) {
-            if (this.buffer[this.pos] === LF) {
+            if (this.buffer[this.pos] === LF3) {
               this.buffer = this.buffer.subarray(this.pos + 1);
               this.pos = 0;
               this.crlfCheck = false;
@@ -17382,7 +17382,7 @@ var require_eventsource_stream = __commonJS((exports, module) => {
             }
             this.crlfCheck = false;
           }
-          if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
+          if (this.buffer[this.pos] === LF3 || this.buffer[this.pos] === CR) {
             if (this.buffer[this.pos] === CR) {
               this.crlfCheck = true;
             }
@@ -17397,7 +17397,7 @@ var require_eventsource_stream = __commonJS((exports, module) => {
           this.eventEndCheck = false;
           continue;
         }
-        if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
+        if (this.buffer[this.pos] === LF3 || this.buffer[this.pos] === CR) {
           if (this.buffer[this.pos] === CR) {
             this.crlfCheck = true;
           }
@@ -35401,6 +35401,37 @@ var checkpointManifestFields = {
 var checkpointManifestContentSchema = exports_external.object(checkpointManifestFields).strict();
 var checkpointManifestV2Schema = checkpointManifestContentSchema.extend({ contentSha256: checkpointSha256Schema }).strict();
 
+// ../../packages/rules/src/canonical-line.ts
+var utf8Encoder2 = new TextEncoder;
+var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
+function encodeCanonicalLine(value) {
+  return utf8Encoder2.encode(`${stableJson(value)}
+`);
+}
+function assertCanonicalLineFraming(bytes, subject) {
+  if (bytes.length === 0 || bytes.at(-1) !== 10) {
+    throw new Error(`${subject} must end with one LF`);
+  }
+  if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) {
+    throw new Error(`${subject} must not contain a UTF-8 BOM`);
+  }
+  for (let index = 0;index < bytes.length - 1; index += 1) {
+    if (bytes[index] === 10 || bytes[index] === 13) {
+      throw new Error(`${subject} must contain exactly one LF and no CR`);
+    }
+  }
+}
+function parseCanonicalLine(bytes, schema, subject) {
+  assertCanonicalLineFraming(bytes, subject);
+  const decoded = utf8Decoder.decode(bytes);
+  const parsed = schema.parse(JSON.parse(decoded.slice(0, -1)));
+  if (decoded !== `${stableJson(parsed)}
+`) {
+    throw new Error(`${subject} bytes are not canonical`);
+  }
+  return parsed;
+}
+
 // ../../packages/rules/src/repository-checkpoint/paths.ts
 var MAX_CHECKPOINT_PART = 10 ** CHECKPOINT_PART_DIGITS - 1;
 async function checkpointShapeKey(shapeName) {
@@ -35427,7 +35458,7 @@ function assertCheckpointPart(part) {
 }
 
 // ../../packages/rules/src/repository-checkpoint/manifest.ts
-var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
+var utf8Decoder2 = new TextDecoder("utf-8", { fatal: true });
 async function validateCheckpointManifest(input) {
   const manifest = checkpointManifestV2Schema.parse(input);
   const { contentSha256, ...content } = manifest;
@@ -35444,8 +35475,8 @@ async function encodeCheckpointManifest(input) {
 `);
 }
 async function parseCheckpointManifest(bytes) {
-  assertCanonicalManifestFraming(bytes);
-  const decoded = utf8Decoder.decode(bytes);
+  assertCanonicalLineFraming(bytes, "Checkpoint manifest");
+  const decoded = utf8Decoder2.decode(bytes);
   const manifest = await validateCheckpointManifest(checkpointManifestV2Schema.parse(JSON.parse(decoded.slice(0, -1))));
   const canonical = await encodeCheckpointManifest(manifest);
   if (!bytesEqual(bytes, canonical)) {
@@ -35491,46 +35522,14 @@ function addSafeCounts(left, right) {
   }
   return total;
 }
-function assertCanonicalManifestFraming(bytes) {
-  if (bytes.length === 0 || bytes.at(-1) !== 10) {
-    throw new Error("Checkpoint manifest must end with one LF");
-  }
-  if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) {
-    throw new Error("Checkpoint manifest must not contain a UTF-8 BOM");
-  }
-  for (let index = 0;index < bytes.length - 1; index += 1) {
-    if (bytes[index] === 10 || bytes[index] === 13) {
-      throw new Error("Checkpoint manifest must contain exactly one LF and no CR");
-    }
-  }
-}
 function bytesEqual(left, right) {
   if (left.length !== right.length)
     return false;
   return left.every((byte, index) => byte === right[index]);
 }
 // ../../packages/rules/src/repository-checkpoint/row-codec.ts
-var utf8Encoder2 = new TextEncoder;
-var utf8Decoder2 = new TextDecoder("utf-8", { fatal: true });
 function parseCheckpointRowLine(bytes) {
-  if (bytes.length === 0 || bytes[bytes.length - 1] !== 10) {
-    throw new Error("Checkpoint row must end with one LF");
-  }
-  if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) {
-    throw new Error("Checkpoint row must not contain a UTF-8 BOM");
-  }
-  for (let index = 0;index < bytes.length - 1; index += 1) {
-    if (bytes[index] === 10 || bytes[index] === 13) {
-      throw new Error("Checkpoint row must contain exactly one LF and no CR");
-    }
-  }
-  const decoded = utf8Decoder2.decode(bytes);
-  const parsed = checkpointRowSchema.parse(JSON.parse(decoded.slice(0, -1)));
-  if (decoded !== `${stableJson(parsed)}
-`) {
-    throw new Error("Checkpoint row bytes are not canonical");
-  }
-  return parsed;
+  return parseCanonicalLine(bytes, checkpointRowSchema, "Checkpoint row");
 }
 // ../../packages/rules/src/repository-checkpoint/streams.ts
 function createCheckpointStreamValidationState(shapeName) {
@@ -35582,6 +35581,327 @@ function addOneSafe(value) {
   }
   return next;
 }
+// ../../packages/rules/src/repository-export/types.ts
+var REPOSITORY_EXPORT_FORMAT_VERSION = 3;
+var REPOSITORY_EXPORT_MEDIA_TYPE = "application/x-ndjson";
+var repositoryExportSha256Schema = exports_external.string().regex(/^[0-9a-f]{64}$/);
+var nonnegativeSafeIntegerSchema2 = exports_external.number().int().nonnegative();
+var positiveSafeIntegerSchema2 = exports_external.number().int().positive();
+var REPOSITORY_EXPORT_ROW_KINDS = [
+  "shape",
+  "thing",
+  "collection",
+  "assertion"
+];
+var REPOSITORY_EXPORT_MODES = ["heads", "ops"];
+var REPOSITORY_EXPORT_SHAPE_PROVENANCES = [
+  "captured",
+  "migration-stamped",
+  "reconstructed"
+];
+var repositoryExportShapeCertificateSchema = exports_external.object({
+  name: exports_external.string().min(1),
+  v: positiveSafeIntegerSchema2,
+  durableId: exports_external.string().min(1),
+  provenance: exports_external.enum(REPOSITORY_EXPORT_SHAPE_PROVENANCES),
+  declared: exports_external.boolean()
+}).strict();
+var repositoryExportReferenceSchema = exports_external.object({
+  wref: exports_external.string().min(1),
+  v: positiveSafeIntegerSchema2.optional(),
+  durableId: exports_external.string().min(1)
+}).strict();
+function refineStrictlyIncreasing(entries, key, message, context) {
+  let previous;
+  entries.forEach((entry, index) => {
+    const current = key(entry);
+    if (previous !== undefined && compareUnsignedUtf8(previous, current) >= 0) {
+      context.addIssue({ code: "custom", path: [index], message });
+    }
+    previous = current;
+  });
+}
+var shapesSchema = exports_external.array(repositoryExportShapeCertificateSchema).superRefine((shapes, context) => {
+  refineStrictlyIncreasing(shapes, (entry) => entry.durableId, "Shape certificates must be unique and strictly increasing by durableId", context);
+});
+var affirmedSchema = exports_external.array(repositoryExportReferenceSchema).superRefine((affirmed, context) => {
+  refineStrictlyIncreasing(affirmed, (entry) => entry.wref, "Affirmed references must be unique and strictly increasing", context);
+});
+var rowEnvelopeFields = {
+  wref: exports_external.string().min(1),
+  durableId: exports_external.string().min(1),
+  version: positiveSafeIntegerSchema2
+};
+var activeRowFields = {
+  ...rowEnvelopeFields,
+  active: exports_external.literal(true),
+  data: exports_external.record(exports_external.string(), jsonValueSchema)
+};
+var activeRowSchema = exports_external.discriminatedUnion("kind", [
+  exports_external.object({
+    ...activeRowFields,
+    kind: exports_external.literal("shape"),
+    shapes: exports_external.array(repositoryExportShapeCertificateSchema).max(0)
+  }).strict(),
+  exports_external.object({
+    ...activeRowFields,
+    kind: exports_external.enum(["thing", "collection"]),
+    shapes: shapesSchema
+  }).strict(),
+  exports_external.object({
+    ...activeRowFields,
+    kind: exports_external.literal("assertion"),
+    shapes: shapesSchema,
+    about: repositoryExportReferenceSchema,
+    affirmed: affirmedSchema
+  }).strict()
+]);
+var tombstoneRowSchema = exports_external.object({
+  ...rowEnvelopeFields,
+  kind: exports_external.enum(REPOSITORY_EXPORT_ROW_KINDS),
+  active: exports_external.literal(false)
+}).strict();
+var repositoryExportRowSchema = exports_external.union([
+  activeRowSchema,
+  tombstoneRowSchema
+]);
+var repositoryExportHeaderSchema = exports_external.object({
+  kind: exports_external.literal("header"),
+  formatVersion: exports_external.literal(REPOSITORY_EXPORT_FORMAT_VERSION),
+  repo: exports_external.string().regex(/^[^/\s]+\/[^/\s]+$/, 'repo must be "<org>/<repo>"'),
+  mode: exports_external.enum(REPOSITORY_EXPORT_MODES),
+  sinceRepoSeq: nonnegativeSafeIntegerSchema2,
+  atRepoSeq: nonnegativeSafeIntegerSchema2
+}).strict().refine((header) => header.atRepoSeq >= header.sinceRepoSeq, "atRepoSeq must not precede sinceRepoSeq");
+var repositoryExportTrailerSchema = exports_external.object({
+  kind: exports_external.literal("trailer"),
+  recordCount: nonnegativeSafeIntegerSchema2,
+  contentSha256: repositoryExportSha256Schema,
+  atRepoSeq: nonnegativeSafeIntegerSchema2
+}).strict();
+function repositoryExportAllowsTombstones(header) {
+  return header.sinceRepoSeq > 0;
+}
+
+// ../../packages/rules/src/repository-export/codec.ts
+function encodeRepositoryExportRow(row) {
+  return encodeCanonicalLine(repositoryExportRowSchema.parse(row));
+}
+function encodeRepositoryExportHeader(header) {
+  return encodeCanonicalLine(repositoryExportHeaderSchema.parse(header));
+}
+function encodeRepositoryExportTrailer(trailer) {
+  return encodeCanonicalLine(repositoryExportTrailerSchema.parse(trailer));
+}
+function parseRepositoryExportRowLine(bytes) {
+  return parseCanonicalLine(bytes, repositoryExportRowSchema, "Repository export row");
+}
+function parseRepositoryExportHeaderLine(bytes) {
+  return parseCanonicalLine(bytes, repositoryExportHeaderSchema, "Repository export header");
+}
+function parseRepositoryExportTrailerLine(bytes) {
+  return parseCanonicalLine(bytes, repositoryExportTrailerSchema, "Repository export trailer");
+}
+// ../../packages/rules/src/repository-export/sha256.ts
+var ROUND_CONSTANTS = Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var INITIAL_STATE = Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+var BLOCK_BYTES = 64;
+function rotr(value, bits) {
+  return (value >>> bits | value << 32 - bits) >>> 0;
+}
+
+class Sha256 {
+  #state = Uint32Array.from(INITIAL_STATE);
+  #schedule = new Uint32Array(64);
+  #block = new Uint8Array(BLOCK_BYTES);
+  #blockLength = 0;
+  #byteLength = 0;
+  #finished = false;
+  update(bytes) {
+    if (this.#finished) {
+      throw new Error("SHA-256 hasher is already finalized");
+    }
+    this.#byteLength += bytes.length;
+    if (!Number.isSafeInteger(this.#byteLength)) {
+      throw new RangeError("SHA-256 input length must be a safe integer");
+    }
+    let offset = 0;
+    if (this.#blockLength > 0) {
+      const take = Math.min(BLOCK_BYTES - this.#blockLength, bytes.length);
+      this.#block.set(bytes.subarray(0, take), this.#blockLength);
+      this.#blockLength += take;
+      offset = take;
+      if (this.#blockLength < BLOCK_BYTES)
+        return;
+      this.#compress(this.#block, 0);
+      this.#blockLength = 0;
+    }
+    while (offset + BLOCK_BYTES <= bytes.length) {
+      this.#compress(bytes, offset);
+      offset += BLOCK_BYTES;
+    }
+    if (offset < bytes.length) {
+      this.#block.set(bytes.subarray(offset), 0);
+      this.#blockLength = bytes.length - offset;
+    }
+  }
+  digestHex() {
+    if (this.#finished) {
+      throw new Error("SHA-256 hasher is already finalized");
+    }
+    this.#finished = true;
+    const tail = new Uint8Array(this.#blockLength < 56 ? 64 : 128);
+    tail.set(this.#block.subarray(0, this.#blockLength), 0);
+    tail[this.#blockLength] = 128;
+    const view = new DataView(tail.buffer);
+    view.setUint32(tail.length - 8, Math.floor(this.#byteLength / 536870912));
+    view.setUint32(tail.length - 4, this.#byteLength << 3 >>> 0);
+    for (let offset = 0;offset < tail.length; offset += BLOCK_BYTES) {
+      this.#compress(tail, offset);
+    }
+    return Array.from(this.#state, (word) => word.toString(16).padStart(8, "0")).join("");
+  }
+  #compress(bytes, offset) {
+    const schedule = this.#schedule;
+    for (let index = 0;index < 16; index += 1) {
+      const at = offset + index * 4;
+      schedule[index] = (bytes[at] << 24 | bytes[at + 1] << 16 | bytes[at + 2] << 8 | bytes[at + 3]) >>> 0;
+    }
+    for (let index = 16;index < 64; index += 1) {
+      const previous = schedule[index - 15];
+      const recent = schedule[index - 2];
+      const s0 = (rotr(previous, 7) ^ rotr(previous, 18) ^ previous >>> 3) >>> 0;
+      const s1 = (rotr(recent, 17) ^ rotr(recent, 19) ^ recent >>> 10) >>> 0;
+      schedule[index] = schedule[index - 16] + s0 + schedule[index - 7] + s1 >>> 0;
+    }
+    const state = this.#state;
+    let a = state[0];
+    let b = state[1];
+    let c = state[2];
+    let d = state[3];
+    let e = state[4];
+    let f = state[5];
+    let g = state[6];
+    let h = state[7];
+    for (let index = 0;index < 64; index += 1) {
+      const s1 = (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) >>> 0;
+      const choice = (e & f ^ ~e & g) >>> 0;
+      const temp1 = h + s1 + choice + ROUND_CONSTANTS[index] + schedule[index] >>> 0;
+      const s0 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) >>> 0;
+      const majority = (a & b ^ a & c ^ b & c) >>> 0;
+      const temp2 = s0 + majority >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    state[0] = a + state[0] >>> 0;
+    state[1] = b + state[1] >>> 0;
+    state[2] = c + state[2] >>> 0;
+    state[3] = d + state[3] >>> 0;
+    state[4] = e + state[4] >>> 0;
+    state[5] = f + state[5] >>> 0;
+    state[6] = g + state[6] >>> 0;
+    state[7] = h + state[7] >>> 0;
+  }
+}
+
+// ../../packages/rules/src/repository-export/digest.ts
+class RepositoryExportDigest {
+  #hash = new Sha256;
+  #rowCount = 0;
+  get rowCount() {
+    return this.#rowCount;
+  }
+  update(rowBytes) {
+    this.#hash.update(rowBytes);
+    this.#rowCount += 1;
+  }
+  finalize() {
+    return this.#hash.digestHex();
+  }
+}
+function createRepositoryExportDigest() {
+  return new RepositoryExportDigest;
+}
 // ../../packages/rules/src/shape-types.ts
 var BASE_PRIMITIVE_TYPES = [
   "number",
@@ -43355,18 +43675,6 @@ function toRepositoryCheckpointSelector(selector) {
 }
 function createRepositoryCheckpointClient(getTrpc, toWarmHubError) {
   return {
-    generate: async (orgName, repoName, options) => {
-      try {
-        const result = await getTrpc().repo.checkpoint.generate.mutate({
-          orgName,
-          repoName,
-          atLeastRepoSeq: options?.atLeastRepoSeq
-        });
-        return normalizeRepositoryCheckpointStatus(result.checkpoint);
-      } catch (error51) {
-        throw toWarmHubError(error51);
-      }
-    },
     status: async (orgName, repoName, selector) => {
       try {
         const result = await getTrpc().repo.checkpoint.status.query({
@@ -43402,22 +43710,464 @@ function createRepositoryCheckpointClient(getTrpc, toWarmHubError) {
       } catch (error51) {
         throw toWarmHubError(error51);
       }
-    },
-    retry: async (orgName, repoName, checkpointId) => {
+    }
+  };
+}
+
+// ../../packages/sdk-ts/src/repository-export/types.ts
+class RepositoryExportError extends Error {
+  reason;
+  name = "RepositoryExportError";
+  constructor(reason, message) {
+    super(message ?? REASON_MESSAGES[reason]);
+    this.reason = reason;
+  }
+}
+var REASON_MESSAGES = {
+  count_mismatch: "Repository export trailer record count does not match the rows read",
+  digest_mismatch: "Repository export content digest does not match the trailer",
+  fence_mismatch: "Repository export header and trailer disagree about atRepoSeq",
+  header_invalid: "Repository export header is invalid",
+  row_invalid: "Repository export row is invalid or not canonical",
+  row_out_of_order: "Repository export rows are not strictly increasing by durableId",
+  since_below_epoch_floor: "Repository export delta base is below the epoch floor",
+  trailer_invalid: "Repository export trailer is invalid",
+  truncated: "Repository export stream ended before its trailer"
+};
+
+class RepositoryExportSession {
+  #streamDigest = createRepositoryExportDigest();
+  #segmentDigest = createRepositoryExportDigest();
+  #segmentRowCount = 0;
+  #header;
+  #lastDurableId;
+  #token;
+  #complete = false;
+  #unverifiable = false;
+  #contentSha256;
+  get header() {
+    return this.#header;
+  }
+  get lastDurableId() {
+    return this.#lastDurableId;
+  }
+  get rowCount() {
+    return this.#streamDigest.rowCount;
+  }
+  get segmentRowCount() {
+    return this.#segmentRowCount;
+  }
+  get contentSha256() {
+    return this.#contentSha256;
+  }
+  finalizeContentSha256() {
+    if (this.#contentSha256 === undefined) {
+      this.#contentSha256 = this.#streamDigest.finalize();
+      this.#complete = true;
+    }
+    return this.#contentSha256;
+  }
+  beginSegment() {
+    this.assertResumable();
+    this.#segmentDigest = createRepositoryExportDigest();
+    this.#segmentRowCount = 0;
+  }
+  markUnverifiable() {
+    this.#unverifiable = true;
+  }
+  finalizeSegment() {
+    return this.#segmentDigest.finalize();
+  }
+  get token() {
+    return this.#token;
+  }
+  set token(value) {
+    this.#token = value;
+  }
+  get complete() {
+    return this.#complete;
+  }
+  markComplete() {
+    this.finalizeContentSha256();
+  }
+  assertResumable() {
+    if (this.#unverifiable) {
+      throw new RepositoryExportError("digest_mismatch", "Repository export session failed verification and cannot be resumed; " + "start a new session");
+    }
+    if (this.#complete) {
+      throw new RepositoryExportError("header_invalid", "Repository export session is already complete; start a new session");
+    }
+  }
+  adoptHeader(header) {
+    this.assertResumable();
+    const previous = this.#header;
+    if (previous !== undefined && (previous.repo !== header.repo || previous.mode !== header.mode || previous.sinceRepoSeq !== header.sinceRepoSeq || previous.atRepoSeq !== header.atRepoSeq)) {
+      throw new RepositoryExportError("header_invalid", "Resumed repository export header does not match the opening header");
+    }
+    this.#header = header;
+  }
+  recordRow(durableId, lineBytes) {
+    if (this.#header?.mode === "heads" && this.#lastDurableId !== undefined && compareUnsignedUtf8(this.#lastDurableId, durableId) >= 0) {
+      throw new RepositoryExportError("row_out_of_order", `Repository export row '${durableId}' does not follow '${this.#lastDurableId}'`);
+    }
+    this.#streamDigest.update(lineBytes);
+    this.#segmentDigest.update(lineBytes);
+    this.#segmentRowCount += 1;
+    this.#lastDurableId = durableId;
+  }
+}
+function createRepositoryExportSession() {
+  return new RepositoryExportSession;
+}
+
+// ../../packages/sdk-ts/src/repository-export/stream.ts
+var LF = 10;
+var utf8 = new TextDecoder;
+function resumedHeader(session) {
+  const header = session.header;
+  if (!header) {
+    throw new RepositoryExportError("header_invalid", "Repository export resumed without an opening header to inherit");
+  }
+  return header;
+}
+async function readHeader(lines, session, expected) {
+  const first = await lines.next();
+  if (first.done)
+    throw new RepositoryExportError("truncated");
+  let header;
+  try {
+    header = parseRepositoryExportHeaderLine(first.value);
+  } catch (error51) {
+    rethrowAs("header_invalid", error51);
+  }
+  if (header.formatVersion !== REPOSITORY_EXPORT_FORMAT_VERSION || expected !== undefined && (header.repo !== expected.repo || header.mode !== expected.mode || expected.sinceRepoSeq !== undefined && header.sinceRepoSeq !== expected.sinceRepoSeq || expected.atRepoSeq !== undefined && header.atRepoSeq !== expected.atRepoSeq)) {
+    throw new RepositoryExportError("header_invalid", expected === undefined ? `Repository export header declares format version ${header.formatVersion}; expected ${REPOSITORY_EXPORT_FORMAT_VERSION}` : `Repository export header describes ${header.repo} (${header.mode}, ` + `${header.sinceRepoSeq}..${header.atRepoSeq}); expected ${expected.repo} ` + `(${expected.mode}${expected.sinceRepoSeq !== undefined ? `, since ${expected.sinceRepoSeq}` : ""}` + `${expected.atRepoSeq !== undefined ? `, at ${expected.atRepoSeq}` : ""})`);
+  }
+  session.adoptHeader(header);
+  return header;
+}
+async function* readLines(source, tail) {
+  let buffer = new Uint8Array(0);
+  for await (const chunk of toAsyncIterable(source)) {
+    const merged = new Uint8Array(buffer.length + chunk.length);
+    merged.set(buffer);
+    merged.set(chunk, buffer.length);
+    buffer = merged;
+    let index = buffer.indexOf(LF);
+    while (index !== -1) {
+      yield buffer.subarray(0, index + 1);
+      buffer = buffer.subarray(index + 1);
+      index = buffer.indexOf(LF);
+    }
+  }
+  tail.unterminated = buffer.length > 0;
+}
+function toAsyncIterable(source) {
+  if (Symbol.asyncIterator in source)
+    return source;
+  return {
+    async* [Symbol.asyncIterator]() {
+      const reader = source.getReader();
       try {
-        const result = await getTrpc().repo.checkpoint.retry.mutate({
-          orgName,
-          repoName,
-          checkpointId
-        });
-        return normalizeRepositoryCheckpointStatus(result.checkpoint);
-      } catch (error51) {
-        throw toWarmHubError(error51);
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            return;
+          if (value)
+            yield value;
+        }
+      } finally {
+        reader.releaseLock();
       }
     }
   };
 }
+function lineKind(bytes) {
+  try {
+    const value = JSON.parse(utf8.decode(bytes));
+    if (value !== null && typeof value === "object" && "kind" in value) {
+      const kind = value.kind;
+      if (typeof kind === "string")
+        return kind;
+    }
+  } catch {}
+  return "";
+}
+function rethrowAs(reason, error51) {
+  if (error51 instanceof RepositoryExportError)
+    throw error51;
+  throw new RepositoryExportError(reason, error51 instanceof Error ? error51.message : undefined);
+}
+async function* readRepositoryExportStream(source, session, expected, options = {}) {
+  yield* readSegment(source, session, expected, options);
+}
+async function restoreRepositoryExportSession(source, options = {}) {
+  const session = createRepositoryExportSession();
+  const replay = readSegment(source, session, undefined, options);
+  let next = await replay.next();
+  while (!next.done)
+    next = await replay.next();
+  return session;
+}
+async function* readSegment(source, session, expected, options) {
+  const tail = { unterminated: false };
+  const lines = readLines(source, tail);
+  try {
+    yield* readVerified(lines, tail, session, expected, options);
+  } finally {
+    await lines.return(undefined);
+  }
+}
+async function* readVerified(lines, tail, session, expected, options) {
+  session.assertResumable();
+  const header = options.resumed === true ? resumedHeader(session) : await readHeader(lines, session, expected);
+  const tombstonesAllowed = repositoryExportAllowsTombstones(header);
+  session.beginSegment();
+  while (true) {
+    const next = await lines.next();
+    if (next.done) {
+      if (options.partial === true)
+        return;
+      throw new RepositoryExportError("truncated");
+    }
+    const bytes = next.value;
+    if (lineKind(bytes) !== "trailer") {
+      let row;
+      try {
+        row = parseRepositoryExportRowLine(bytes);
+      } catch (error51) {
+        rethrowAs("row_invalid", error51);
+      }
+      if (!row.active && !tombstonesAllowed) {
+        throw new RepositoryExportError("row_invalid", "Repository export tombstone is not legal in a full export");
+      }
+      session.recordRow(row.durableId, bytes);
+      yield row;
+      continue;
+    }
+    let trailer;
+    try {
+      trailer = parseRepositoryExportTrailerLine(bytes);
+      if (trailer.atRepoSeq !== header.atRepoSeq) {
+        throw new RepositoryExportError("fence_mismatch");
+      }
+      if (trailer.recordCount !== session.segmentRowCount) {
+        throw new RepositoryExportError("count_mismatch");
+      }
+      if (trailer.contentSha256 !== session.finalizeSegment()) {
+        throw new RepositoryExportError("digest_mismatch");
+      }
+    } catch (error51) {
+      session.markUnverifiable();
+      if (error51 instanceof RepositoryExportError)
+        throw error51;
+      rethrowAs("trailer_invalid", error51);
+    }
+    if (!(await lines.next()).done || tail.unterminated) {
+      throw new RepositoryExportError("trailer_invalid", "Repository export stream continues past its trailer");
+    }
+    session.markComplete();
+    return;
+  }
+}
 
+// ../../packages/sdk-ts/src/repository-export/client.ts
+var EPOCH_FLOOR_CODE = "since-below-epoch-floor";
+var DEFAULT_POLL_INTERVAL_MS = 1000;
+var MIN_POLL_INTERVAL_MS = 50;
+var MAX_DOWNLOAD_ATTEMPTS = 3;
+function buildPath(orgName, repoName, query) {
+  const params = new URLSearchParams;
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== undefined)
+      params.set(key, String(value));
+  }
+  const search = params.toString();
+  return `/api/repos/${encodeURIComponent(orgName)}/${encodeURIComponent(repoName)}/export${search ? `?${search}` : ""}`;
+}
+function abortReason(signal) {
+  const reason = signal?.reason;
+  return reason instanceof Error ? reason : new Error("Repository export was aborted");
+}
+function pollIntervalMs(requested) {
+  if (requested === undefined || !Number.isFinite(requested)) {
+    return DEFAULT_POLL_INTERVAL_MS;
+  }
+  return Math.max(requested, MIN_POLL_INTERVAL_MS);
+}
+async function delay(ms, signal) {
+  if (signal?.aborted)
+    throw abortReason(signal);
+  await new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortReason(signal));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function exportHttpError(response, httpError) {
+  let body;
+  try {
+    body = await response.clone().json();
+  } catch {}
+  if ((body?.code ?? body?.error?.code) === EPOCH_FLOOR_CODE) {
+    return new RepositoryExportError("since_below_epoch_floor", body?.message);
+  }
+  if (body?.code !== undefined && body.error === undefined) {
+    return await httpError(new Response(JSON.stringify({ error: body }), {
+      status: response.status,
+      headers: { "content-type": "application/json" }
+    }));
+  }
+  return await httpError(response);
+}
+function isDownloadEnvelope(value) {
+  const envelope = value;
+  return typeof envelope?.url === "string" && envelope.url !== "" && typeof envelope.expiresAt === "number" && typeof envelope.atRepoSeq === "number" && typeof envelope.recordCount === "number" && typeof envelope.contentSha256 === "string";
+}
+async function readDownloadEnvelope(response) {
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    throw new RepositoryExportError("header_invalid", "Repository export redemption did not return a JSON download envelope");
+  }
+  if (!isDownloadEnvelope(body)) {
+    throw new RepositoryExportError("header_invalid", "Repository export download envelope must carry url, expiresAt, atRepoSeq, recordCount, and contentSha256");
+  }
+  return body;
+}
+function assertAttested(session, envelope) {
+  const fence = session.header?.atRepoSeq;
+  if (fence !== envelope.atRepoSeq) {
+    throw new RepositoryExportError("fence_mismatch", `Repository export download is pinned to ${fence}; the redemption named ${envelope.atRepoSeq}`);
+  }
+  if (session.rowCount !== envelope.recordCount) {
+    throw new RepositoryExportError("count_mismatch", `Repository export download carried ${session.rowCount} rows; the redemption named ${envelope.recordCount}`);
+  }
+  if (session.contentSha256 !== envelope.contentSha256) {
+    throw new RepositoryExportError("digest_mismatch", "Repository export download digest does not match the digest the redemption named");
+  }
+}
+function createRepositoryExportClient(transport, httpError, download = (url2, init) => globalThis.fetch(url2, init)) {
+  const request = async (path, signal) => {
+    const response = await transport(path, {
+      method: "GET",
+      headers: { accept: REPOSITORY_EXPORT_MEDIA_TYPE },
+      ...signal ? { signal } : {}
+    });
+    if (!response.ok && response.status !== 202) {
+      throw await exportHttpError(response, httpError);
+    }
+    return response;
+  };
+  const prepare = async (orgName, repoName, options = {}) => {
+    const response = await request(buildPath(orgName, repoName, {
+      mode: options.mode ?? "heads",
+      sinceRepoSeq: options.sinceRepoSeq,
+      atRepoSeq: options.atRepoSeq,
+      prefer: "async"
+    }), options.signal);
+    const accepted = await response.json();
+    if (typeof accepted.exportToken !== "string" || typeof accepted.atRepoSeq !== "number") {
+      throw new RepositoryExportError("header_invalid", "Repository export async request did not return an exportToken and atRepoSeq");
+    }
+    return { exportToken: accepted.exportToken, atRepoSeq: accepted.atRepoSeq };
+  };
+  const stream = (orgName, repoName, options = {}) => {
+    const cursor = options.session?.lastDurableId ?? options.afterDurableId;
+    if (cursor !== undefined && (options.token !== undefined || options.session?.token !== undefined || options.prefer === "async")) {
+      throw new RepositoryExportError("header_invalid", `Repository export token download cannot continue from '${cursor}': redemption returns the whole prepared object. ` + "Start a new session and redeem the token again.");
+    }
+    if (options.afterDurableId !== undefined && options.session?.header === undefined) {
+      throw new RepositoryExportError("header_invalid", "Repository export afterDurableId needs a session carrying the opening header; " + "reuse the session the broken stream wrote, or rebuild one with restoreRepositoryExportSession");
+    }
+    return streamExport(orgName, repoName, options);
+  };
+  return { prepare, stream };
+  async function* streamExport(orgName, repoName, options) {
+    const session = options.session ?? createRepositoryExportSession();
+    const resumed = session.header;
+    const signal = options.signal;
+    const query = {
+      mode: resumed?.mode ?? options.mode ?? "heads",
+      sinceRepoSeq: resumed?.sinceRepoSeq ?? options.sinceRepoSeq,
+      atRepoSeq: resumed?.atRepoSeq ?? options.atRepoSeq,
+      afterDurableId: session.lastDurableId ?? options.afterDurableId
+    };
+    const expected = {
+      repo: `${orgName}/${repoName}`,
+      mode: query.mode,
+      ...options.sinceRepoSeq === undefined ? {} : { sinceRepoSeq: options.sinceRepoSeq },
+      ...options.atRepoSeq === undefined ? {} : { atRepoSeq: options.atRepoSeq }
+    };
+    if (options.token !== undefined && session.token !== undefined && options.token !== session.token) {
+      throw new RepositoryExportError("header_invalid", `Repository export session was redeeming token ${session.token}; ` + `resuming it with token ${options.token} would splice two exports`);
+    }
+    const token = options.token ?? session.token;
+    if (token !== undefined) {
+      session.token = token;
+      yield* downloadPrepared(token);
+      return;
+    }
+    if (options.prefer === "async") {
+      const prepared = await prepare(orgName, repoName, {
+        mode: query.mode,
+        ...query.sinceRepoSeq === undefined ? {} : { sinceRepoSeq: query.sinceRepoSeq },
+        ...query.atRepoSeq === undefined ? {} : { atRepoSeq: query.atRepoSeq },
+        ...signal ? { signal } : {}
+      });
+      session.token = prepared.exportToken;
+      yield* downloadPrepared(prepared.exportToken);
+      return;
+    }
+    const response = await request(buildPath(orgName, repoName, query), signal);
+    if (!response.body)
+      throw new RepositoryExportError("truncated");
+    yield* readRepositoryExportStream(response.body, session, expected, {
+      resumed: query.afterDurableId !== undefined
+    });
+    async function* downloadPrepared(exportToken) {
+      for (let attempt = 1;; attempt += 1) {
+        const envelope = await redeem(exportToken);
+        try {
+          yield* readObject(envelope);
+          return;
+        } catch (error51) {
+          const transportFault = !(error51 instanceof RepositoryExportError) || error51.reason === "truncated";
+          if (!transportFault || session.rowCount > 0 || attempt >= MAX_DOWNLOAD_ATTEMPTS || signal?.aborted === true) {
+            throw error51;
+          }
+        }
+      }
+    }
+    async function* readObject(envelope) {
+      const object2 = await download(envelope.url, signal ? { signal } : {});
+      if (!object2.ok || !object2.body) {
+        await object2.body?.cancel();
+        throw new RepositoryExportError("truncated", `Repository export download returned HTTP ${object2.status}`);
+      }
+      yield* readRepositoryExportStream(object2.body, session, expected, {
+        resumed: false
+      });
+      assertAttested(session, envelope);
+    }
+    async function redeem(exportToken) {
+      const path = buildPath(orgName, repoName, { token: exportToken });
+      while (true) {
+        const pending = await request(path, signal);
+        if (pending.status !== 202)
+          return await readDownloadEnvelope(pending);
+        await delay(pollIntervalMs(options.pollIntervalMs), signal);
+      }
+    }
+  }
+}
 // ../../packages/sdk-ts/src/shape-preflight.ts
 function shapeDefinitionPreflightError(name, data, verb) {
   const result = validateShapeDefinition(data, verb === "revise" ? { allowUnsafeFieldNamePaths: collectUnsafeShapeFieldNamePaths(data) } : undefined);
@@ -44496,7 +45246,7 @@ function createStreamingSubmissionHandle(input, deps) {
 // ../../packages/sdk-ts/package.json
 var package_default = {
   name: "@warmhub/sdk-ts",
-  version: "0.106.0",
+  version: "0.108.0",
   private: false,
   type: "module",
   description: "The TypeScript SDK for WarmHub — create repos, commit and query data, and compound knowledge with your AI agents.",
@@ -44534,6 +45284,7 @@ var package_default = {
   sideEffects: false,
   files: [
     "dist",
+    "CHANGELOG.md",
     "README.md"
   ],
   publishConfig: {
@@ -44600,6 +45351,7 @@ var package_default = {
     "@vitest/coverage-v8": "catalog:",
     "@warmhub/backend": "workspace:*",
     "@warmhub/rules": "workspace:*",
+    pako: "2.1.0",
     "@types/react": "catalog:",
     react: "19.2.6",
     tsup: "8.5.1",
@@ -45059,6 +45811,7 @@ class WarmHubClient {
   getToken;
   compatibilityCheck;
   overrideNoticePrinted = false;
+  repositoryExport = createRepositoryExportClient((path, init) => this.fetchWithAuth(`${this.apiUrl.replace(/\/$/, "")}${path}`, init), (response) => this.httpResponseError(response), (url2, init) => (this.fetchImpl ?? globalThis.fetch)(url2, init));
   noteCompatibilityOverride() {
     if (this.overrideNoticePrinted)
       return;
@@ -45577,6 +46330,8 @@ class WarmHubClient {
   };
   repo = {
     checkpoint: createRepositoryCheckpointClient(() => this.trpc, toWarmHubError),
+    export: (orgName, repoName, options) => this.repositoryExport.stream(orgName, repoName, options),
+    exportPrepare: (orgName, repoName, options) => this.repositoryExport.prepare(orgName, repoName, options),
     get: async (orgName, repoName) => {
       try {
         return await this.trpc.repo.get.query({
@@ -49363,7 +50118,7 @@ function corruptedAuthError(path, cause) {
 function isAuthLockError(error51, authPath) {
   return error51 instanceof Error && error51.code === "ELOCKED" && (error51.file === undefined || error51.file === authPath);
 }
-function delay(ms) {
+function delay2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function getTokenInfo(profile) {
@@ -49485,7 +50240,7 @@ async function getValidToken(profile) {
           duration_ms: Date.now() - refreshStarted,
           error_name: err instanceof Error ? err.name : "Unknown"
         });
-        await delay(1000);
+        await delay2(1000);
         log.info("auth.refresh.retry", { profile: profileName, attempt: 2 });
         let retryStarted = Date.now();
         try {
@@ -49821,6 +50576,9 @@ function shouldGuardDomain(domainPath, canonicalVerb, args) {
   if (domainPath[0] === "repo" && domainPath[1] === "checkpoint" && canonicalVerb === "verify") {
     return false;
   }
+  if (domainPath[0] === "repo" && canonicalVerb === "verify") {
+    return false;
+  }
   return true;
 }
 async function probeCapabilities(ctx) {
@@ -56640,7 +57398,7 @@ var NUL = String.fromCharCode(0);
 function findInvalidControlByte(data, rootLabel = "data") {
   const segs = [];
   const pos = visit(data, segs);
-  return pos === -1 ? null : { path: buildPath(rootLabel, segs), position: pos };
+  return pos === -1 ? null : { path: buildPath2(rootLabel, segs), position: pos };
 }
 function visit(value, segs) {
   if (typeof value === "string")
@@ -56671,7 +57429,7 @@ function visit(value, segs) {
   }
   return -1;
 }
-function buildPath(root, segs) {
+function buildPath2(root, segs) {
   let out = root;
   for (const s of segs)
     out += typeof s === "number" ? `[${s}]` : `.${s}`;
@@ -62192,7 +62950,7 @@ class StreamingByteReader {
   #loadedBytes = 0;
   position = 0;
   constructor(source) {
-    this.#iterator = toAsyncIterable(source)[Symbol.asyncIterator]();
+    this.#iterator = toAsyncIterable2(source)[Symbol.asyncIterator]();
   }
   async peekU32() {
     const bytes = await this.readExact(4);
@@ -62279,7 +63037,7 @@ class StreamingByteReader {
     }
   }
 }
-function toAsyncIterable(source) {
+function toAsyncIterable2(source) {
   if (Symbol.asyncIterator in source)
     return source;
   return {
@@ -63018,12 +63776,6 @@ var checkpointFlags = {
   "repo-seq": flag.number({
     description: "Repository sequence for the checkpoint"
   }),
-  "at-least-repo-seq": flag.number({
-    description: "Generate at or after this repository sequence"
-  }),
-  wait: flag.boolean({
-    description: "Poll until the checkpoint completes or fails"
-  }),
   latest: flag.boolean({
     description: "Use the latest completed checkpoint"
   }),
@@ -63042,19 +63794,10 @@ var CHECKPOINT_ID_EXAMPLE = "0198f6d5-78aa-7000-8000-000000000001";
 var CHECKPOINT_ACCESS_EXAMPLE = "wh repo checkpoint access acme/widgets --latest --archive";
 var CHECKPOINT_DOWNLOAD_EXAMPLE = "wh repo checkpoint download acme/widgets --latest --archive --output checkpoint.zip";
 var CHECKPOINT_READ_NOTE = "Requires unrestricted repo:read plus repo:checkpoint-read.";
-var CHECKPOINT_MANAGEMENT_NOTE = "Requires unrestricted repo:read, repo:checkpoint-read, and repo:checkpoint-generate (or repo:admin for compatibility).";
-var generateFlags = {
-  "at-least-repo-seq": checkpointFlags["at-least-repo-seq"],
-  wait: checkpointFlags.wait
-};
 var statusFlags = {
   checkpoint: checkpointFlags.checkpoint,
   "repo-seq": checkpointFlags["repo-seq"]
 };
-var retryFlags = {
-  checkpoint: checkpointFlags.checkpoint,
-  wait: checkpointFlags.wait
-};
 var accessFlags = {
   latest: checkpointFlags.latest,
   checkpoint: checkpointFlags.checkpoint,
@@ -63070,17 +63813,17 @@ var downloadFlags = {
 function repoFor(ctx, args) {
   return parseOrgRepo(getRepoRef(ctx) ?? args[0], ctx.config);
 }
-function requireSequence(value, flagName) {
+function requireSequence(value) {
   if (value === undefined)
     return;
   if (!Number.isSafeInteger(value) || value < 0) {
-    throw new CliError(2 /* UserInput */, "USER_INPUT", `${flagName} must be a non-negative safe integer`);
+    throw new CliError(2 /* UserInput */, "USER_INPUT", "--repo-seq must be a non-negative safe integer");
   }
   return value;
 }
 function selectCheckpoint(flags) {
   const checkpointId = flags.checkpoint;
-  const repoSeq = requireSequence(flags["repo-seq"], "--repo-seq");
+  const repoSeq = requireSequence(flags["repo-seq"]);
   if (checkpointId === undefined === (repoSeq === undefined)) {
     usageError("Provide exactly one of --checkpoint or --repo-seq.", `wh repo checkpoint status acme/widgets --checkpoint ${CHECKPOINT_ID_EXAMPLE}`);
   }
@@ -63144,43 +63887,6 @@ function printCheckpoint(ctx, result) {
       ctx.out(`Failure: ${result.failureCode}`);
   });
 }
-async function waitForCompletion(ctx, org, repo2, initial) {
-  let result = initial;
-  let delayMs = 200;
-  while (result.state === "queued" || result.state === "running") {
-    ctx.status(`Checkpoint ${result.checkpointId} is ${result.state}; waiting…`);
-    await delay2(delayMs, ctx.signal);
-    result = await checkpointClient(ctx).status(org, repo2, {
-      checkpointId: result.checkpointId
-    });
-    delayMs = Math.min(delayMs * 2, 5000);
-  }
-  return result;
-}
-function delay2(ms, signal) {
-  return new Promise((resolve4, reject) => {
-    if (signal?.aborted) {
-      reject(new Error("CLI invocation cancelled"));
-      return;
-    }
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(new Error("CLI invocation cancelled"));
-    };
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve4();
-    }, ms);
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-var handleGenerate = async (ctx, { args, flags }) => {
-  const { org, repo: repo2 } = repoFor(ctx, args);
-  const result = await checkpointClient(ctx).generate(org, repo2, {
-    atLeastRepoSeq: requireSequence(flags["at-least-repo-seq"], "--at-least-repo-seq")
-  });
-  printCheckpoint(ctx, flags.wait ? await waitForCompletion(ctx, org, repo2, result) : result);
-};
 var handleStatus2 = async (ctx, { args, flags }) => {
   const { org, repo: repo2 } = repoFor(ctx, args);
   printCheckpoint(ctx, await checkpointClient(ctx).status(org, repo2, selectCheckpoint(flags)));
@@ -63189,14 +63895,6 @@ var handleLatest = async (ctx, { args }) => {
   const { org, repo: repo2 } = repoFor(ctx, args);
   printCheckpoint(ctx, await checkpointClient(ctx).latest(org, repo2));
 };
-var handleRetry = async (ctx, { args, flags }) => {
-  if (!flags.checkpoint) {
-    usageError("--checkpoint is required for retry.", `wh repo checkpoint retry acme/widgets --checkpoint ${CHECKPOINT_ID_EXAMPLE}`);
-  }
-  const { org, repo: repo2 } = repoFor(ctx, args);
-  const result = await checkpointClient(ctx).retry(org, repo2, flags.checkpoint);
-  printCheckpoint(ctx, flags.wait ? await waitForCompletion(ctx, org, repo2, result) : result);
-};
 var handleDownload = async (ctx, { args, flags }) => {
   if (!flags.output) {
     usageError("--output PATH|- is required for download.", CHECKPOINT_DOWNLOAD_EXAMPLE);
@@ -63253,16 +63951,8 @@ var handleVerify = async (ctx, { args }) => {
 };
 var CHECKPOINT_SUBDOMAIN = defineDomain({
   name: "checkpoint",
-  summary: "Generate, access, download, and verify repository checkpoints",
+  summary: "Access, download, and verify stored repository checkpoints",
   verbs: {
-    generate: {
-      summary: "Generate a repository checkpoint",
-      args: "[org/repo]",
-      flags: generateFlags,
-      notes: [CHECKPOINT_MANAGEMENT_NOTE],
-      examples: ["wh repo checkpoint generate acme/widgets --wait"],
-      handler: handleGenerate
-    },
     status: {
       summary: "Show one checkpoint status",
       args: "[org/repo]",
@@ -63283,16 +63973,6 @@ var CHECKPOINT_SUBDOMAIN = defineDomain({
       examples: ["wh repo checkpoint latest acme/widgets"],
       handler: handleLatest
     },
-    retry: {
-      summary: "Retry a failed checkpoint",
-      args: "[org/repo]",
-      flags: retryFlags,
-      notes: [CHECKPOINT_MANAGEMENT_NOTE, "Requires --checkpoint."],
-      examples: [
-        `wh repo checkpoint retry acme/widgets --checkpoint ${CHECKPOINT_ID_EXAMPLE} --wait`
-      ],
-      handler: handleRetry
-    },
     access: {
       summary: "Show a short-lived checkpoint artifact URL",
       args: "[org/repo]",
@@ -63684,6 +64364,346 @@ var handleCreate6 = async (ctx, { flags, args }) => {
   });
 };
 
+// ../../packages/warmhub-cli/src/domains/repo/export-file.ts
+import { createReadStream as createReadStream7 } from "node:fs";
+import { open as open5, truncate } from "node:fs/promises";
+var LF2 = 10;
+async function scanRepositoryExportFile(path2, options = {}) {
+  const counter = { completeBytes: 0 };
+  const session = await restoreRepositoryExportSession(countedChunks(path2, counter), options);
+  return { session, completeBytes: counter.completeBytes };
+}
+async function openExportSink(ctx, output, resumeFrom) {
+  if (output === "-") {
+    const writeBinary = ctx.writeBinary;
+    if (!writeBinary) {
+      throw new CliError(1 /* Runtime */, "UNKNOWN", "Binary stdout is unavailable for this command context.");
+    }
+    return {
+      write: async (bytes) => {
+        if (await writeBinary(bytes))
+          return;
+        throw new CliError(1 /* Runtime */, "UNKNOWN", "Export output closed before the stream finished.");
+      },
+      close: async () => {
+        return;
+      }
+    };
+  }
+  if (resumeFrom !== undefined)
+    await truncate(output, resumeFrom);
+  const handle = await openOutput(output, resumeFrom === undefined);
+  return {
+    write: (bytes) => writeAll(handle, bytes),
+    close: async () => {
+      await handle.sync();
+      await handle.close();
+    }
+  };
+}
+async function openOutput(output, fresh) {
+  try {
+    return await open5(output, fresh ? "wx" : "a", 384);
+  } catch (error51) {
+    if (error51.code === "EEXIST") {
+      throw new CliError(2 /* UserInput */, "USER_INPUT", `Refusing to overwrite existing output path '${output}'.`, error51, "Delete it, choose another --output, or pass --resume to continue an interrupted export.");
+    }
+    throw error51;
+  }
+}
+async function* countedChunks(path2, counter) {
+  let read = 0;
+  for await (const chunk of createReadStream7(path2)) {
+    const bytes = chunk;
+    const lastLf = bytes.lastIndexOf(LF2);
+    if (lastLf !== -1)
+      counter.completeBytes = read + lastLf + 1;
+    read += bytes.byteLength;
+    yield bytes;
+  }
+}
+
+// ../../packages/warmhub-cli/src/domains/repo/export.ts
+var exportFlags = {
+  output: flag.string({
+    description: "Write the export to PATH, or - for stdout",
+    constraints: { nonEmpty: true }
+  }),
+  mode: flag.string({
+    description: "Export mode: heads (default)",
+    constraints: { choices: ["heads", "ops"] },
+    conflictsWith: ["resume"]
+  }),
+  "since-repo-seq": flag.number({
+    description: "Delta base: export only what changed after this sequence",
+    conflictsWith: ["resume", "token"]
+  }),
+  "at-repo-seq": flag.number({
+    description: "Pin the export to this repository sequence",
+    conflictsWith: ["resume", "token"]
+  }),
+  async: flag.boolean({
+    description: "Prepare the export server-side and print the token that redeems it",
+    conflictsWith: ["resume", "token"]
+  }),
+  wait: flag.boolean({
+    description: "Download the prepared export instead of printing its token",
+    requires: [{ flag: "async", mustBeTrue: true }],
+    conflictsWith: ["resume", "token"]
+  }),
+  token: flag.string({
+    description: "Download the prepared export this token names",
+    constraints: { nonEmpty: true },
+    conflictsWith: ["async", "wait", "resume", "since-repo-seq", "at-repo-seq"]
+  }),
+  resume: flag.boolean({
+    description: "Continue an interrupted export already at --output PATH",
+    conflictsWith: [
+      "async",
+      "wait",
+      "token",
+      "mode",
+      "since-repo-seq",
+      "at-repo-seq"
+    ]
+  })
+};
+var POLL_INTERVAL_MS = 2000;
+var EXPORT_EXAMPLE = "wh repo export acme/widgets --output widgets.ndjson --format json";
+var ASYNC_EXAMPLE = "wh repo export acme/widgets --async";
+function requireSequence2(value, flagName) {
+  if (value === undefined)
+    return;
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new CliError(2 /* UserInput */, "USER_INPUT", `${flagName} must be a non-negative safe integer`);
+  }
+  return value;
+}
+function printReceipt(ctx, header, session, contentSha256) {
+  const result = {
+    repo: header.repo,
+    mode: header.mode,
+    sinceRepoSeq: header.sinceRepoSeq,
+    atRepoSeq: header.atRepoSeq,
+    recordCount: session.rowCount,
+    contentSha256
+  };
+  writeOutput(ctx, result, () => {
+    ctx.out(`Repository: ${result.repo}`);
+    ctx.out(`Mode: ${result.mode}`);
+    if (result.sinceRepoSeq > 0)
+      ctx.out(`Delta base: ${result.sinceRepoSeq}`);
+    ctx.out(`Repository sequence: ${result.atRepoSeq}`);
+    ctx.out(`Records: ${result.recordCount}`);
+    ctx.out(`SHA-256: ${result.contentSha256}`);
+  });
+}
+function exportFailure(error51, asked) {
+  const asyncRefusal = asked.async && asked.mode !== "ops";
+  if (error51 instanceof RepositoryExportError) {
+    if (error51.reason === "since_below_epoch_floor") {
+      throw new CliError(2 /* UserInput */, "USER_INPUT", "The delta base has expired; run a full export.", error51, "Re-run without --since-repo-seq.");
+    }
+    throw new CliError(4 /* Backend */, "BACKEND", error51.message, error51);
+  }
+  if (error51 instanceof WarmHubError) {
+    if (error51.status === 429) {
+      throw new CliError(4 /* Backend */, "RATE_LIMITED", "Another repository export is already streaming for this organization.", error51, "Retry with --async --wait to queue this export instead.");
+    }
+    if (error51.status === 501) {
+      throw new CliError(4 /* Backend */, "BACKEND", asyncRefusal ? "Asynchronous repository export is not enabled on this deployment." : 'Export mode "ops" is not enabled on this deployment.', error51, asyncRefusal ? "Re-run without --async." : "Use --mode heads.");
+    }
+    if (error51.status === 500 && (asked.async || asked.token)) {
+      throw new CliError(4 /* Backend */, "BACKEND", "The repository export job failed.", error51, asked.token ? "The token is spent; prepare a new export with --async." : "Re-run the command; it starts a new export job.");
+    }
+  }
+  throw error51;
+}
+var handleExport = async (ctx, { args, flags }) => {
+  const output = flags.output;
+  if (flags.async && !flags.wait) {
+    if (output) {
+      usageError("--output is unused when --async only prints the token. Add --wait to download now, or redeem the token later with --token.", ASYNC_EXAMPLE);
+    }
+    return await prepareExport(ctx, args, flags);
+  }
+  if (!output) {
+    usageError("--output PATH|- is required for export.", EXPORT_EXAMPLE);
+  }
+  if (output === "-" && ctx.format !== "pretty") {
+    throw new CliError(2 /* UserInput */, "USER_INPUT", "Stdout output requires --format pretty; JSON and JSONL cannot carry export bytes.");
+  }
+  if (flags.resume && output === "-") {
+    usageError("--resume needs a file; stdout cannot be continued.", EXPORT_EXAMPLE);
+  }
+  const { org, repo: repo2 } = parseOrgRepo(getRepoRef(ctx) ?? args[0], ctx.config);
+  let session = createRepositoryExportSession();
+  let resumeFrom;
+  if (flags.resume) {
+    const scan = await resumeScan(output);
+    session = scan.session;
+    const opened = requireHeader(session);
+    if (opened.repo !== `${org}/${repo2}`) {
+      throw new CliError(2 /* UserInput */, "USER_INPUT", `'${output}' is an export of ${opened.repo}, not ${org}/${repo2}.`, undefined, `Resume it as ${opened.repo}, or choose another --output.`);
+    }
+    if (session.complete) {
+      printReceipt(ctx, opened, session, session.finalizeContentSha256());
+      return;
+    }
+    resumeFrom = scan.completeBytes;
+  }
+  const rows = ctx.client.repo.export(org, repo2, {
+    mode: flags.mode,
+    sinceRepoSeq: requireSequence2(flags["since-repo-seq"], "--since-repo-seq"),
+    atRepoSeq: requireSequence2(flags["at-repo-seq"], "--at-repo-seq"),
+    ...flags.async || flags.token ? {
+      ...flags.token ? { token: flags.token } : { prefer: "async" },
+      pollIntervalMs: POLL_INTERVAL_MS
+    } : {},
+    session,
+    ...ctx.signal ? { signal: ctx.signal } : {}
+  });
+  if (flags.async || flags.token) {
+    ctx.status("Waiting for the export to finish on the server…");
+  }
+  let sink;
+  let headerWritten = resumeFrom !== undefined;
+  const write = async (bytes) => {
+    sink ??= await openExportSink(ctx, output, resumeFrom);
+    await sink.write(bytes);
+  };
+  const writeHeader = async () => {
+    if (headerWritten)
+      return;
+    headerWritten = true;
+    await write(encodeRepositoryExportHeader(requireHeader(session)));
+  };
+  try {
+    for await (const row of rows) {
+      await writeHeader();
+      await write(encodeRepositoryExportRow(row));
+    }
+    await writeHeader();
+    const header = requireHeader(session);
+    const contentSha256 = session.finalizeContentSha256();
+    await write(encodeRepositoryExportTrailer({
+      kind: "trailer",
+      recordCount: session.rowCount,
+      contentSha256,
+      atRepoSeq: header.atRepoSeq
+    }));
+    await sink?.close();
+    if (output === "-") {
+      ctx.status(`Exported ${session.rowCount} records at ${header.atRepoSeq}`);
+      return;
+    }
+    ctx.status(`Wrote repository export to ${output}`);
+    printReceipt(ctx, header, session, contentSha256);
+  } catch (error51) {
+    try {
+      await sink?.close();
+    } catch (closeError) {
+      ctx.status(`Could not flush the partial export: ${closeError instanceof Error ? closeError.message : "unknown error"}`);
+    }
+    exportFailure(error51, {
+      async: flags.async === true,
+      token: flags.token !== undefined,
+      mode: flags.mode ?? "heads"
+    });
+  }
+};
+async function prepareExport(ctx, args, flags) {
+  const { org, repo: repo2 } = parseOrgRepo(getRepoRef(ctx) ?? args[0], ctx.config);
+  let prepared;
+  try {
+    prepared = await ctx.client.repo.exportPrepare(org, repo2, {
+      mode: flags.mode,
+      sinceRepoSeq: requireSequence2(flags["since-repo-seq"], "--since-repo-seq"),
+      atRepoSeq: requireSequence2(flags["at-repo-seq"], "--at-repo-seq"),
+      ...ctx.signal ? { signal: ctx.signal } : {}
+    });
+  } catch (error51) {
+    exportFailure(error51, {
+      async: true,
+      token: false,
+      mode: flags.mode ?? "heads"
+    });
+  }
+  writeOutput(ctx, prepared, () => {
+    ctx.out(`Export token: ${prepared.exportToken}`);
+    ctx.out(`Repository sequence: ${prepared.atRepoSeq}`);
+  });
+  const modeFlag = (flags.mode ?? "heads") === "heads" ? "" : ` --mode ${flags.mode}`;
+  ctx.status(`Download it with: wh repo export ${org}/${repo2} --token ${prepared.exportToken}${modeFlag} --output PATH`);
+}
+function requireHeader(session) {
+  const header = session.header;
+  if (!header) {
+    throw new CliError(4 /* Backend */, "BACKEND", "Repository export ended without a header.");
+  }
+  return header;
+}
+async function resumeScan(output) {
+  try {
+    return await scanRepositoryExportFile(output, { partial: true });
+  } catch (error51) {
+    if (error51.code === "ENOENT") {
+      throw new CliError(2 /* UserInput */, "USER_INPUT", `No export to resume at '${output}'.`, error51, "Re-run without --resume to start a new export.");
+    }
+    throw error51;
+  }
+}
+var handleVerify2 = async (ctx, { args }) => {
+  const file2 = args[0];
+  if (!file2) {
+    usageError("Usage: wh repo verify <file>", "wh repo verify widgets.ndjson");
+  }
+  try {
+    const { session } = await scanRepositoryExportFile(file2);
+    printReceipt(ctx, requireHeader(session), session, session.finalizeContentSha256());
+  } catch (error51) {
+    if (error51 instanceof RepositoryExportError) {
+      throw new CliError(4 /* Backend */, "BACKEND", error51.message, error51);
+    }
+    if (error51.code === "ENOENT") {
+      throw new CliError(4 /* Backend */, "BACKEND", "Repository export file could not be read", error51);
+    }
+    throw error51;
+  }
+};
+var EXPORT_VERB = {
+  summary: "Export a repository as verified NDJSON (format v3)",
+  args: "[org/repo]",
+  flags: exportFlags,
+  notes: [
+    "Requires unrestricted repo:read plus repo:checkpoint-read.",
+    "The stream is verified as it arrives: header, canonical rows, row order, record count, and content digest.",
+    "One synchronous export streams per organization at a time; --async queues instead.",
+    "A bare --async prints the export token and exits; --wait downloads it now, --token downloads it later.",
+    "Redeeming a token answers with a short-lived download link for the prepared export, which the CLI then fetches and checks against the record count and digest the server named.",
+    "An interrupted token download restarts from the beginning; re-run the same command, since redeeming a token again is free.",
+    "An interrupted export resumes from the same file with --resume."
+  ],
+  examples: [
+    EXPORT_EXAMPLE,
+    "wh repo export acme/widgets --output delta.ndjson --since-repo-seq 120",
+    ASYNC_EXAMPLE,
+    "wh repo export acme/widgets --output widgets.ndjson --token TOKEN",
+    "wh repo export acme/widgets --output widgets.ndjson --async --wait",
+    "wh repo export acme/widgets --output widgets.ndjson --resume"
+  ],
+  handler: handleExport
+};
+var VERIFY_VERB = {
+  summary: "Verify a saved repository export locally",
+  args: "<file>",
+  notes: [
+    "Reads only the named local file: no profile, no authentication, no server."
+  ],
+  examples: ["wh repo verify widgets.ndjson"],
+  handler: handleVerify2
+};
+
 // ../../packages/warmhub-cli/src/domains/repo/lifecycle.ts
 var confirmFlags2 = {
   yes: flag.boolean({ short: "y", description: "Skip confirmation prompt" })
@@ -64189,6 +65209,8 @@ var REPO_DOMAIN = defineDomain({
       ],
       handler: handleUpdate3
     },
+    export: EXPORT_VERB,
+    verify: VERIFY_VERB,
     archive: {
       summary: "Archive a repo (blocks new commits)",
       args: "<org/repo>",
@@ -68187,6 +69209,9 @@ function isLocalOnlyInvocation(invocation) {
   if (invocation.commandPath[0] === "repo" && invocation.commandPath[1] === "checkpoint" && invocation.commandPath[2] === "verify") {
     return true;
   }
+  if (invocation.commandPath[0] === "repo" && invocation.commandPath[1] === "verify") {
+    return true;
+  }
   return invocation.commandPath[0] === "help" && invocation.positionals[0] === "update";
 }
 function resolveLogLevel(flagLevel, env) {
@@ -68210,7 +69235,7 @@ function resolveLogLevel(flagLevel, env) {
 // package.json
 var package_default3 = {
   name: "@warmhub/cli",
-  version: "0.108.0",
+  version: "0.110.0",
   private: false,
   type: "module",
   description: "The wh CLI for WarmHub — create repos, commit and query data, and compound knowledge with your AI agents.",
@@ -68835,5 +69860,5 @@ process.exitCode = interceptedExitCode === undefined ? await runPreparedCli(laun
   version: package_default3.version
 }) : interceptedExitCode;
 
-//# debugId=7A410E9FAA03CF1E64756E2164756E21
-//# warmhub-cli-build-info {"cliVersion":"0.108.0","sdkVersion":"0.106.0"}
+//# debugId=D94FA6CB8612CBFC64756E2164756E21
+//# warmhub-cli-build-info {"cliVersion":"0.110.0","sdkVersion":"0.108.0"}