@warmhub/sdk-ts 0.65.0 → 0.67.0

package/dist/{chunk-C2Q4D3JM.js → chunk-2KN2JWJU.js}

@@ -3,10 +3,21 @@ import { TRPCClientError, createTRPCProxyClient, splitLink, httpBatchLink, httpL
 // src/index.ts
 
 // ../rules/src/builtin-shapes.ts
-var BUILTIN_SHAPE_NAMES = ["Pair", "Triple", "Set", "List"];
+var BUILTIN_SHAPE_NAMES = ["Pair", "Set", "List"];
+var RETIRED_COLLECTION_SHAPE_NAMES = ["Triple"];
+var RESERVED_COLLECTION_SHAPE_NAMES = [
+  ...BUILTIN_SHAPE_NAMES,
+  ...RETIRED_COLLECTION_SHAPE_NAMES
+];
 function isBuiltinCollectionShape(name) {
   return BUILTIN_SHAPE_NAMES.includes(name);
 }
+function isRetiredCollectionShape(name) {
+  return RETIRED_COLLECTION_SHAPE_NAMES.includes(name);
+}
+function isReservedCollectionShape(name) {
+  return RESERVED_COLLECTION_SHAPE_NAMES.includes(name);
+}
 var BUILTIN_CONTENT_SHAPE_NAMES = ["Content"];
 var STORED_CONTENT_NAMES = ["Readme", "Agents"];
 var SYNTHESIZED_CONTENT_NAMES = ["LlmsTxt"];
@@ -29,29 +40,6 @@ var DEFAULT_STREAM_APPEND_CHUNK_SIZE = 1e3;
 var MAX_STREAM_APPEND_OPERATION_COUNT = 1e4;
 
 // ../rules/src/commit-types.ts
-function isCollectionAbout(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return false;
-  const record = value;
-  const keys = Object.keys(record);
-  if (keys.length !== 1) return false;
-  const key = keys[0];
-  if (key !== "pair" && key !== "triple" && key !== "set" && key !== "list")
-    return false;
-  return Array.isArray(record[key]);
-}
-function collectionAboutType(about) {
-  if ("pair" in about) return "pair";
-  if ("triple" in about) return "triple";
-  if ("set" in about) return "set";
-  return "list";
-}
-function collectionAboutMembers(about) {
-  if ("pair" in about) return about.pair;
-  if ("triple" in about) return about.triple;
-  if ("set" in about) return about.set;
-  return about.list;
-}
 function splitLocalPath(name) {
   const idx = name.indexOf("/");
   if (idx === -1) return null;
@@ -364,23 +352,8 @@ var PLATFORM_STATUS_STATUSES = [
     enum: PLATFORM_STATUS_STATUSES.map((status) => status.key)}});
 
 // ../rules/src/tokens.ts
-var ALLOC_TOKEN_RE = /\$(\d+)/g;
-var REF_TOKEN_RE = /#(\d+)/g;
+var COMMIT_TOKEN_SYNTAX_REMOVED_MESSAGE = "$N/#N commit-token syntax is no longer supported. Use explicit names and explicit wrefs. For assertions about newly created things, create the thing with a deterministic name and set about to that wref in the same commit.";
 var ANY_TOKEN_RE = /[$#]\d+/;
-function findAllocTokens(s) {
-  const tokens = [];
-  for (const m of s.matchAll(ALLOC_TOKEN_RE)) {
-    tokens.push(Number.parseInt(m[1], 10));
-  }
-  return tokens;
-}
-function findRefTokens(s) {
-  const tokens = [];
-  for (const m of s.matchAll(REF_TOKEN_RE)) {
-    tokens.push(Number.parseInt(m[1], 10));
-  }
-  return tokens;
-}
 function hasAnyTokens(s) {
   return ANY_TOKEN_RE.test(s);
 }
@@ -388,146 +361,35 @@ function hasAnyTokens(s) {
 // ../rules/src/preflight-commit.ts
 function preflightCommitDiagnostics(operations, options) {
   const errors = [];
-  tokenHygiene(operations, errors);
-  illegalOpSequences(operations, errors);
+  rejectCommitTokenSyntax(operations, errors);
+  illegalOpSequences(operations, errors, options?.checkAddAdd ?? true);
   return errors;
 }
 function getOpName(op) {
   return op.name;
 }
-function collectionAboutMembersOrEmpty(about) {
-  if (about && typeof about !== "string" && isCollectionAbout(about)) {
-    return collectionAboutMembers(about);
-  }
-  return [];
-}
 function tokenStringFields(op) {
-  const fields = [getOpName(op)];
+  const fields = [getOpName(op), op.newName];
   if (typeof op.about === "string") {
     fields.push(op.about);
-  } else {
-    fields.push(...collectionAboutMembersOrEmpty(op.about));
   }
   if (op.members) {
     fields.push(...op.members);
   }
   return fields;
 }
-function collectMisusedAllocFields(op) {
-  const result = [];
-  if (op.operation === "add") {
-    if (typeof op.about === "string") {
-      result.push({ value: op.about });
-    }
-    for (const m of collectionAboutMembersOrEmpty(op.about)) {
-      result.push({ value: m, context: "collection member" });
-    }
-    if (op.members) {
-      for (const m of op.members) {
-        result.push({ value: m, context: "collection member" });
-      }
-    }
-  } else {
-    const name = getOpName(op);
-    if (name) {
-      result.push({ value: name });
-    }
-  }
-  return result;
-}
-function tokenHygiene(operations, errors) {
-  let anyTokens = false;
-  for (const op of operations) {
-    for (const f of tokenStringFields(op)) {
-      if (f && hasAnyTokens(f)) {
-        anyTokens = true;
-        break;
-      }
-    }
-    if (anyTokens) break;
-  }
-  if (!anyTokens) return;
-  const allocations = /* @__PURE__ */ new Map();
-  for (let i = 0; i < operations.length; i++) {
-    const op = operations[i];
-    if (!op || op.operation !== "add" || !op.name) continue;
-    const local = splitLocalPath(op.name);
-    if (!local) {
-      const allocs = findAllocTokens(op.name);
-      if (allocs.length > 0) {
-        errors.push({
-          code: "ALLOC_TOKEN_IN_SHAPE_NAME",
-          operationIndex: i,
-          message: `Allocation token $${allocs[0]} not allowed in shape name "${op.name}"`
-        });
-      }
-      continue;
-    }
-    const segments = local.bareName.split("/");
-    const lastSegment = segments[segments.length - 1];
-    const lastSegAllocs = lastSegment ? findAllocTokens(lastSegment) : [];
-    for (let s = 0; s < segments.length - 1; s++) {
-      const seg = segments[s];
-      if (!seg) continue;
-      const earlyAllocs = findAllocTokens(seg);
-      if (earlyAllocs.length > 0) {
-        errors.push({
-          code: "ALLOC_TOKEN_WRONG_SEGMENT",
-          operationIndex: i,
-          message: `Allocation token $${earlyAllocs[0]} must be in the last segment of ADD name "${op.name}"`
-        });
-      }
-    }
-    for (const tokenNum of lastSegAllocs) {
-      if (tokenNum <= 0) {
-        errors.push({
-          code: "INVALID_TOKEN_NUMBER",
-          operationIndex: i,
-          message: `Token number must be positive: $${tokenNum}`
-        });
-      }
-      if (allocations.has(tokenNum)) {
-        errors.push({
-          code: "DUPLICATE_ALLOC_TOKEN",
-          operationIndex: i,
-          message: `Token $${tokenNum} allocated more than once`
-        });
-      }
-      allocations.set(tokenNum, { opIndex: i });
-    }
-  }
+function rejectCommitTokenSyntax(operations, errors) {
   for (let i = 0; i < operations.length; i++) {
     const op = operations[i];
     if (!op) continue;
     for (const field of tokenStringFields(op)) {
-      if (!field) continue;
-      const refs = findRefTokens(field);
-      for (const tokenNum of refs) {
-        if (tokenNum <= 0) {
-          errors.push({
-            code: "INVALID_TOKEN_NUMBER",
-            operationIndex: i,
-            message: `Token number must be positive: #${tokenNum}`
-          });
-        }
-        if (!allocations.has(tokenNum)) {
-          errors.push({
-            code: "UNRESOLVED_REF_TOKEN",
-            operationIndex: i,
-            message: `Reference #${tokenNum} has no matching allocation $${tokenNum}`
-          });
-        }
-      }
-    }
-    const misusedFields = collectMisusedAllocFields(op);
-    for (const { value, context } of misusedFields) {
-      const allocs = findAllocTokens(value);
-      if (allocs.length > 0) {
+      if (field && hasAnyTokens(field)) {
         errors.push({
-          code: "MISUSED_ALLOC_TOKEN",
+          code: "COMMIT_TOKEN_SYNTAX_REMOVED",
           operationIndex: i,
-          message: context ? `Use #${allocs[0]} to reference token ${allocs[0]} in ${context}, not $${allocs[0]}` : `Use #${allocs[0]} to reference token ${allocs[0]}, not $${allocs[0]}`
+          message: COMMIT_TOKEN_SYNTAX_REMOVED_MESSAGE
         });
+        break;
       }
     }
   }
@@ -553,6 +415,13 @@ function illegalOpSequences(operations, errors, checkAddAdd) {
       const curr = history[i];
       if (!prev || !curr) continue;
       const pair = `${prev.operation}+${curr.operation}`;
+      if (checkAddAdd && pair === "add+add") {
+        errors.push({
+          code: "ILLEGAL_OP_SEQUENCE",
+          operationIndex: curr.index,
+          message: `Cannot add "${qualName}" twice in the same commit`
+        });
+      }
       if (pair === "revise+add") {
         errors.push({
           code: "ILLEGAL_OP_SEQUENCE",
@@ -565,8 +434,10 @@ function illegalOpSequences(operations, errors, checkAddAdd) {
 }
 
 // ../rules/src/preflight-operation.ts
-var collectionTypes = ["pair", "triple", "set", "list"];
+var collectionTypes = ["pair", "set", "list"];
 var collectionOps = ["add", "revise"];
+var COLLECTION_CREATE_REQUIRES_NAME_MESSAGE = "Collection create requires a name. Collections are ordinary named things (ADR 0004).";
+var COLLECTION_ABOUT_REMOVED_MESSAGE = 'about accepts a wref. Create the collection as its own named operation, then point the assertion at it. Prefer deterministic relationship names, for example: [{"operation":"add","kind":"collection","type":"pair","name":"a-b-relationship","members":["A","B"]},{"operation":"add","kind":"assertion","about":"Pair/a-b-relationship","name":"Assertion/example","data":{}}]. For CLI usage, use wh commit submit --file with the two operations.';
 function preflightOpDiagnostics(op, operationIndex) {
   const errors = [];
   errors.push(...builtinShapeGuard(op, operationIndex));
@@ -579,17 +450,36 @@ function preflightOpDiagnostics(op, operationIndex) {
 function builtinShapeGuard(op, operationIndex) {
   const errors = [];
   const name = op.name;
-  if (op.kind === "shape" && name && isBuiltinShape(name)) {
+  if (name && isRetiredCollectionShape(name)) {
+    errors.push({
+      code: "RESERVED_NAME",
+      operationIndex,
+      message: `Shape "${name}" is a retired collection shape and cannot be written manually`
+    });
+  }
+  if (op.operation === "rename" && (op.kind === "shape" || op.name !== void 0 && !splitLocalPath(op.name)) && op.newName && isRetiredCollectionShape(op.newName)) {
+    errors.push({
+      code: "RESERVED_NAME",
+      operationIndex,
+      message: `Shape "${op.newName}" is a retired collection shape and cannot be written manually`
+    });
+  } else if (op.operation !== "retract" && op.kind === "shape" && name && isBuiltinShape(name)) {
     errors.push({
       code: "RESERVED_NAME",
       operationIndex,
       message: `Shape "${name}" is a built-in shape and cannot be ${op.operation === "add" ? "created" : "revised"} manually`
     });
   }
-  if (op.kind === "thing" && name) {
+  if (name) {
     const local = splitLocalPath(name);
-    if (local && isBuiltinCollectionShape(local.shapePrefix)) {
-      const message = op.operation === "add" ? `Cannot add kind="thing" under built-in shape "${local.shapePrefix}". Use kind="collection" or the about sugar instead.` : `Cannot revise kind="thing" under built-in shape "${local.shapePrefix}". Collections are immutable.`;
+    if (local && isRetiredCollectionShape(local.shapePrefix)) {
+      errors.push({
+        code: "VALIDATION_ERROR",
+        operationIndex,
+        message: `Cannot ${op.operation} under retired collection shape "${local.shapePrefix}". Triple is read-only and retired for new collection writes.`
+      });
+    } else if (op.kind === "thing" && local && isBuiltinCollectionShape(local.shapePrefix)) {
+      const message = op.operation === "add" ? `Cannot add kind="thing" under built-in shape "${local.shapePrefix}". Use kind="collection" instead.` : `Cannot revise kind="thing" under built-in shape "${local.shapePrefix}". Use kind="collection" to revise a collection.`;
       errors.push({
         code: "VALIDATION_ERROR",
         operationIndex,
@@ -627,109 +517,100 @@ function contentNameGuard(op, operationIndex) {
 function plusSignGuard(op, operationIndex) {
   const errors = [];
   const name = op.name;
-  if (op.kind === "collection") return errors;
-  if (name?.includes("+")) {
-    const local = splitLocalPath(name);
-    if (local && isBuiltinCollectionShape(local.shapePrefix)) return errors;
+  if (op.newName?.includes("+")) {
     errors.push({
       code: "VALIDATION_ERROR",
       operationIndex,
-      message: `Name "${name}" contains reserved character "+". The "+" character is reserved for collection names.`
-    });
-  }
-  return errors;
-}
-function validateCollectionAbouts(op, operationIndex) {
-  const errors = [];
-  if (!op.about || typeof op.about === "string") return errors;
-  if (!isCollectionAbout(op.about)) {
-    const keys = typeof op.about === "object" && op.about !== null ? Object.keys(op.about) : [];
-    errors.push({
-      code: "VALIDATION_ERROR",
-      operationIndex,
-      message: `Structured about must have exactly one key: pair, triple, set, or list. Got: ${keys.join(", ") || typeof op.about}`
+      message: `Name "${op.newName}" contains reserved character "+". The "+" character is reserved for the historical collection auto-name namespace and is not allowed in user-supplied names.`
     });
     return errors;
   }
-  const tag = collectionAboutType(op.about);
-  const members = collectionAboutMembers(op.about);
-  for (let i = 0; i < members.length; i++) {
-    if (typeof members[i] !== "string") {
+  if (name?.includes("+")) {
+    if (op.kind === "collection" && op.operation === "add") {
       errors.push({
         code: "VALIDATION_ERROR",
         operationIndex,
-        message: `Collection member at index ${i} must be a string, got ${typeof members[i]}`
+        message: `Name "${name}" contains reserved character "+". The "+" character is reserved for the historical collection auto-name namespace and is not allowed in user-supplied names.`
       });
+      return errors;
     }
-  }
-  const arityError = collectionArityError(tag, members);
-  if (arityError) {
+    if (op.kind === "collection") return errors;
+    const local = splitLocalPath(name);
+    if (local && isReservedCollectionShape(local.shapePrefix)) return errors;
     errors.push({
       code: "VALIDATION_ERROR",
       operationIndex,
-      message: arityError
+      message: `Name "${name}" contains reserved character "+". The "+" character is reserved for the historical collection auto-name namespace and is not allowed in user-supplied names.`
     });
   }
   return errors;
 }
+function validateCollectionAbouts(op, operationIndex) {
+  const errors = [];
+  if (!op.about || typeof op.about === "string") return errors;
+  errors.push({
+    code: "VALIDATION_ERROR",
+    operationIndex,
+    message: COLLECTION_ABOUT_REMOVED_MESSAGE
+  });
+  return errors;
+}
 function validateCollectionOps(op, operationIndex) {
   const errors = [];
   if (op.kind !== "collection") return errors;
   if (!collectionOps.includes(op.operation)) {
+    return errors;
+  }
+  if (op.operation === "add" && !op.name) {
     errors.push({
       code: "VALIDATION_ERROR",
       operationIndex,
-      message: `Collection kind only supports "add" or "revise" operation, got "${op.operation}"`
+      message: COLLECTION_CREATE_REQUIRES_NAME_MESSAGE
     });
-    return errors;
   }
-  if (op.operation === "add") {
-    if (!op.type || !collectionTypes.includes(op.type)) {
-      errors.push({
-        code: "VALIDATION_ERROR",
-        operationIndex,
-        message: `Collection "type" must be one of: pair, triple, set, list. Got: "${op.type ?? ""}"`
-      });
-    }
-    if (!op.members || !Array.isArray(op.members)) {
-      errors.push({
-        code: "VALIDATION_ERROR",
-        operationIndex,
-        message: 'Collection requires a "members" array'
-      });
-    } else {
-      for (let i = 0; i < op.members.length; i++) {
-        if (typeof op.members[i] !== "string") {
-          errors.push({
-            code: "VALIDATION_ERROR",
-            operationIndex,
-            message: `Collection member at index ${i} must be a string`
-          });
-        }
-      }
-    }
-    if (op.type && op.members) {
-      const arityError = collectionArityError(
-        op.type,
-        op.members
-      );
-      if (arityError) {
+  if (!op.type || !collectionTypes.includes(op.type)) {
+    errors.push({
+      code: "VALIDATION_ERROR",
+      operationIndex,
+      message: `Collection "type" must be one of: pair, set, list. Got: "${op.type ?? ""}"`
+    });
+  }
+  if (!op.members || !Array.isArray(op.members)) {
+    errors.push({
+      code: "VALIDATION_ERROR",
+      operationIndex,
+      message: 'Collection requires a "members" array'
+    });
+  } else {
+    for (let i = 0; i < op.members.length; i++) {
+      if (typeof op.members[i] !== "string") {
         errors.push({
           code: "VALIDATION_ERROR",
           operationIndex,
-          message: arityError
+          message: `Collection member at index ${i} must be a string`
         });
       }
     }
   }
+  if (op.type && op.members) {
+    const arityError = collectionArityError(
+      op.type,
+      op.members
+    );
+    if (arityError) {
+      errors.push({
+        code: "VALIDATION_ERROR",
+        operationIndex,
+        message: arityError
+      });
+    }
+  }
   return errors;
 }
 function collectionArityError(tag, members) {
   switch (tag) {
     case "pair":
       return members.length !== 2 ? `Pair requires exactly 2 members, got ${members.length}` : null;
-    case "triple":
-      return members.length !== 3 ? `Triple requires exactly 3 members, got ${members.length}` : null;
     case "set":
     case "list":
       return members.length < 1 ? `${tag === "set" ? "Set" : "List"} requires at least 1 member, got 0` : null;
@@ -741,7 +622,7 @@ function preflightOpDiagnostics2(op, operationIndex) {
   return preflightOpDiagnostics(op, operationIndex);
 }
 function preflightCommitDiagnostics2(operations, options) {
-  return preflightCommitDiagnostics(operations);
+  return preflightCommitDiagnostics(operations, options);
 }
 
 // ../rules/src/reserved-orgs.ts
@@ -7224,7 +7105,7 @@ function normalizeOptionalTypeSpec(spec) {
   return { spec, optionalByType: false };
 }
 function isFieldOptional(fieldKey, typeSpec) {
-  const optionalByKey = fieldKey !== void 0 && fieldKey.endsWith("?");
+  const optionalByKey = fieldKey?.endsWith("?");
   return optionalByKey || normalizeOptionalTypeSpec(typeSpec).optionalByType;
 }
 
@@ -8034,17 +7915,39 @@ function shapeDefinitionPreflightError(name, data, verb) {
 }
 
 // src/collection-operation-normalize.ts
-var collectionTypes2 = /* @__PURE__ */ new Set([
-  "pair",
-  "triple",
-  "set",
-  "list"
-]);
+var collectionTypes2 = /* @__PURE__ */ new Set(["pair", "set", "list"]);
 function normalizeBackendCollectionAdd(operation, source) {
+  const normalized = normalizeCollectionWrite(operation, source, "add");
+  return {
+    operation: "add",
+    kind: "collection",
+    name: normalized.name,
+    type: normalized.type,
+    members: normalized.members,
+    ...operation.skipExisting === true ? { skipExisting: true } : {}
+  };
+}
+function normalizeBackendCollectionRevise(operation, source) {
+  const normalized = normalizeCollectionWrite(operation, source, "revise");
+  if (!normalized.name) {
+    throw new Error(`${source}: collection revise requires a target name`);
+  }
+  return {
+    operation: "revise",
+    kind: "collection",
+    name: normalized.name,
+    type: normalized.type,
+    members: normalized.members,
+    ...typeof operation.expectedVersion === "number" ? { expectedVersion: operation.expectedVersion } : {},
+    ...typeof operation.leaseId === "string" && operation.leaseId.length > 0 ? { leaseId: operation.leaseId } : {}
+  };
+}
+function normalizeCollectionWrite(operation, source, writeOperation) {
   const diagnostics = preflightOpDiagnostics2(
     {
-      operation: "add",
+      operation: writeOperation,
       kind: "collection",
+      name: typeof operation.name === "string" ? operation.name : void 0,
       type: typeof operation.type === "string" ? operation.type : void 0,
       members: Array.isArray(operation.members) ? operation.members : void 0
     },
@@ -8058,35 +7961,40 @@ function normalizeBackendCollectionAdd(operation, source) {
   const type = normalizeCollectionType(operation.type);
   if (!type) {
     throw new Error(
-      `${source}: collection add requires 'type' to be one of: pair, triple, set, list`
+      `${source}: collection ${writeOperation} requires 'type' to be one of: pair, set, list`
     );
   }
   if (!Array.isArray(operation.members)) {
-    throw new Error(`${source}: collection add requires a 'members' array`);
+    throw new Error(
+      `${source}: collection ${writeOperation} requires a 'members' array`
+    );
   }
   const name = normalizeOptionalName(operation.name);
-  if (operation.name !== void 0 && !name) {
+  if (!name) {
     throw new Error(
-      `${source}: collection add name must be a non-empty string when provided`
+      `${source}: collection ${writeOperation} name must be a non-empty string`
     );
   }
-  assertNoUnsupportedCollectionAddFields(operation, source);
+  assertNoUnsupportedCollectionFields(operation, source, writeOperation);
   return {
-    operation: "add",
-    kind: "collection",
-    ...name ? { name } : {},
+    name,
     type,
-    members: operation.members,
-    ...operation.skipExisting === true ? { skipExisting: true } : {}
+    members: operation.members
   };
 }
-function assertNoUnsupportedCollectionAddFields(operation, source) {
-  const unsupportedFields = ["about", "aboutWref", "shapeWref", "data"].filter(
+function assertNoUnsupportedCollectionFields(operation, source, writeOperation) {
+  const unsupportedFields = [
+    "about",
+    "aboutWref",
+    "shapeWref",
+    "data",
+    ...writeOperation === "revise" ? ["skipExisting"] : []
+  ].filter(
     (field) => operation[field] !== void 0
   );
   if (unsupportedFields.length > 0) {
     throw new Error(
-      `${source}: collection add does not support ${unsupportedFields.map((field) => `'${field}'`).join(", ")}`
+      `${source}: collection ${writeOperation} does not support ${unsupportedFields.map((field) => `'${field}'`).join(", ")}`
     );
   }
 }
@@ -8137,14 +8045,12 @@ function toBackendStreamOperation(operation) {
         `${kind2} revise operation no longer supports 'active' \u2014 use retract('${name}') instead`
       );
     }
+    if (kind2 === "collection") {
+      return normalizeBackendCollectionRevise(operation, "commit.apply");
+    }
     if (operation.data === void 0) {
       throw new Error(`${kind2} revise operation requires 'data'`);
     }
-    if (kind2 === "collection") {
-      throw new Error(
-        `collection revise is no longer supported \u2014 use retract('${name}') instead`
-      );
-    }
     if (kind2 === "assertion") {
       return {
         operation: "revise",
@@ -8184,6 +8090,9 @@ function toBackendStreamOperation(operation) {
     if (!("about" in operation) || operation.about === void 0) {
       throw new Error("assertion add operation requires 'about'");
     }
+    if (typeof operation.about !== "string") {
+      throw new Error(COLLECTION_ABOUT_REMOVED_MESSAGE);
+    }
     if (operation.data === void 0) {
       throw new Error("assertion add operation requires 'data'");
     }
@@ -8333,10 +8242,9 @@ var DEFINITE_CLIENT_REJECT_CODES = /* @__PURE__ */ new Set([
   "CONFLICT",
   "ALREADY_RETRACTED",
   "ARCHIVED",
-  // Pre-apply rejections from stream/service.ts: applyRateLimit() and the
-  // unresolved-token check both throw before any operation lands, so the
-  // first-chunk wrapper would discard structured retry/validation detail
-  // (retryAfter, the failing token, etc.).
+  // Pre-apply rejections from stream/service.ts throw before any operation
+  // lands, so the first-chunk wrapper would discard structured
+  // retry/validation detail (retryAfter, validation diagnostics, etc.).
   "RATE_LIMITED",
   "TOO_MANY_REQUESTS",
   "UNRESOLVED_TOKEN"
@@ -8390,34 +8298,14 @@ function computeBackoffDelayMs(attempt, policy) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-var TOKEN_REF_REGEX = /[$#]\d+/;
-function stringHasTokenRef(value) {
-  return typeof value === "string" && TOKEN_REF_REGEX.test(value);
-}
-function structuralValueHasTokenRef(value, seen = /* @__PURE__ */ new WeakSet()) {
-  if (stringHasTokenRef(value)) return true;
-  if (value !== null && typeof value === "object") {
-    if (seen.has(value)) return false;
-    seen.add(value);
-    if (Array.isArray(value)) {
-      return value.some((entry) => structuralValueHasTokenRef(entry, seen));
-    }
-    return Object.values(value).some(
-      (entry) => structuralValueHasTokenRef(entry, seen)
-    );
-  }
-  return false;
-}
-function opUsesTokens(op) {
-  return stringHasTokenRef(op.name) || stringHasTokenRef(op.wref) || structuralValueHasTokenRef(op.about) || stringHasTokenRef(op.aboutWref) || structuralValueHasTokenRef(op.members) || structuralValueHasTokenRef(op.data);
-}
 
 // src/stream-submit-submit.ts
 var StreamValidationError = class extends Error {
-  code = "VALIDATION_ERROR";
+  code;
   status = 400;
-  constructor(message) {
+  constructor(message, code = "VALIDATION_ERROR") {
     super(message);
+    this.code = code;
     this.name = "WarmHubError";
   }
 };
@@ -8442,6 +8330,7 @@ async function submitOperationsViaStream(client, args) {
     }
     return streamOperation;
   });
+  validateNormalizedOperations(operations);
   const chunkSize = normalizeChunkSize(args.chunkSize);
   let streamId = args.streamId ?? createStreamId();
   const policy = args.streamId !== void 0 ? false : resolveRetryPolicy(args.retry);
@@ -8456,7 +8345,6 @@ async function submitOperationsViaStream(client, args) {
     let attempt = 1;
     let priorAttemptAmbiguous = false;
     const chunkIsAtomic = chunk.length === 1;
-    const chunkUsesTokens = chunk.some(opUsesTokens);
     while (true) {
       try {
         const appendResult = await client.stream.append({
@@ -8481,7 +8369,7 @@ async function submitOperationsViaStream(client, args) {
         if (chunkResults.length === 0 && !priorAttemptAmbiguous && isDefiniteClientError(cause)) {
           throw cause;
         }
-        if (chunkResults.length === 0 && chunkIsAtomic && !chunkUsesTokens && policy !== false && attempt < policy.maxAttempts && isTransientStreamFailure(cause)) {
+        if (chunkResults.length === 0 && chunkIsAtomic && policy !== false && attempt < policy.maxAttempts && isTransientStreamFailure(cause)) {
           await sleep(computeBackoffDelayMs(attempt, policy));
           attempt += 1;
           priorAttemptAmbiguous = true;
@@ -8531,6 +8419,20 @@ async function submitOperationsViaStream(client, args) {
   }
   return result;
 }
+function validateNormalizedOperations(operations) {
+  const diagnostics = preflightCommitDiagnostics2(operations).filter(
+    (diagnostic) => !isServerAuthoritativeSequenceDiagnostic(diagnostic)
+  );
+  const firstDiagnostic = diagnostics[0];
+  if (!firstDiagnostic) return;
+  throw new StreamValidationError(
+    `Invalid operation at index ${firstDiagnostic.operationIndex}: ${firstDiagnostic.message}`,
+    firstDiagnostic.code
+  );
+}
+function isServerAuthoritativeSequenceDiagnostic(diagnostic) {
+  return diagnostic.code === "ILLEGAL_OP_SEQUENCE" && diagnostic.message.includes("Cannot revise then add ");
+}
 function isAllSubmittedOperationsFailed(result, submittedOperationCount) {
   if (submittedOperationCount <= 0) {
     return false;
@@ -8867,6 +8769,9 @@ function toBackendOp(op) {
           `OperationBuilder: assertion add '${name2}' missing required 'about'`
         );
       }
+      if (typeof about !== "string") {
+        throw new Error(COLLECTION_ABOUT_REMOVED_MESSAGE);
+      }
       return {
         operation: "add",
         kind: kind2,
@@ -8892,9 +8797,7 @@ function toBackendOp(op) {
   }
   const kind = normalizeReviseKind(op, name);
   if (kind === "collection") {
-    throw new Error(
-      `OperationBuilder: collection revise is no longer supported \u2014 use retract('${name}') instead`
-    );
+    return normalizeBackendCollectionRevise({ ...op, name }, "OperationBuilder");
   }
   return {
     operation: "revise",
@@ -8919,7 +8822,9 @@ function toPreflightOp(op, kind) {
   return {
     operation: op.operation,
     kind,
-    name: op.name ?? op.wref
+    name: op.name ?? op.wref,
+    type: getCollectionType(op),
+    members: getCollectionMembers(op)
   };
 }
 function throwAggregatedMessages(messages) {
@@ -8951,9 +8856,7 @@ function preflightCheckAdd(op, kind) {
   if (op.name) {
     messages.push(...preflightCheckCommon("ADD", kind, op.name, getAddData(op)));
   }
-  if (kind === "assertion" && getAddAbout(op) === void 0 && // Token-bearing names defer to validate() so the more specific token
-  // diagnostics surface instead of this eager check.
-  !(op.name && hasAnyTokens(op.name))) {
+  if (kind === "assertion" && getAddAbout(op) === void 0) {
     messages.push(
       `ADD assertion '${op.name}' missing required 'about' \u2014 for hierarchical thing names set kind: 'thing' explicitly`
     );
@@ -8975,17 +8878,16 @@ function preflightCheckAdd(op, kind) {
   }
   throwAggregatedMessages(messages);
 }
-function preflightCheckRevise(kind, name, data) {
+function preflightCheckRevise(kind, name, op) {
   const messages = [];
-  if (data === void 0) {
+  if (kind !== "collection" && op.data === void 0) {
     messages.push(`OperationBuilder: ${kind} revise requires 'data'`);
   }
   messages.push(
-    ...preflightCheckCommon("REVISE", kind, name, data),
-    ...preflightOpDiagnostics2(
-      toPreflightOp({ operation: "revise", name, data }, kind),
-      0
-    ).map((diagnostic) => diagnostic.message)
+    ...preflightCheckCommon("REVISE", kind, name, op.data),
+    ...preflightOpDiagnostics2(toPreflightOp({ ...op, name }, kind), 0).map(
+      (diagnostic) => diagnostic.message
+    )
   );
   throwAggregatedMessages(messages);
 }
@@ -9086,7 +8988,10 @@ var OperationBuilder = class {
         { ...normalized },
         target
       );
-      preflightCheckRevise(reviseKind, target, normalized.data);
+      preflightCheckRevise(reviseKind, target, {
+        operation: "revise",
+        ...normalized
+      });
     }
     const frozen = Object.freeze({
       operation: "revise",
@@ -9230,6 +9135,36 @@ var OperationBuilder = class {
         }
       }
     }
+    const operationDiagnostics = this.ops.flatMap((op, operationIndex) => {
+      if (op.operation === "add") {
+        return preflightOpDiagnostics2(
+          toPreflightOp(op, normalizeAddKind(op)),
+          operationIndex
+        );
+      }
+      if (op.operation === "revise") {
+        const target = op.name ?? op.wref;
+        return preflightOpDiagnostics2(
+          toPreflightOp(op, target ? normalizeReviseKind(op, target) : "thing"),
+          operationIndex
+        );
+      }
+      return preflightOpDiagnostics2(
+        {
+          operation: "retract",
+          kind: op.kind,
+          name: op.name
+        },
+        operationIndex
+      );
+    });
+    for (const diagnostic of operationDiagnostics) {
+      errors.push({
+        code: diagnostic.code,
+        operationIndex: diagnostic.operationIndex,
+        message: diagnostic.message
+      });
+    }
     const preflightOps = this.ops.filter((op) => op.operation !== "retract").map((op) => {
       if (op.operation === "add") {
         return toPreflightOp(op, normalizeAddKind(op));
@@ -9240,7 +9175,9 @@ var OperationBuilder = class {
         target ? normalizeReviseKind(op, target) : "thing"
       );
     });
-    const diagnostics = preflightCommitDiagnostics2(preflightOps);
+    const diagnostics = preflightCommitDiagnostics2(preflightOps, {
+      checkAddAdd: false
+    });
     for (const diagnostic of diagnostics) {
       errors.push({
         code: diagnostic.code,
@@ -9341,7 +9278,7 @@ function validateWarmHubClientOptions(options) {
     throw new TypeError(`Unknown WarmHubClient option "${key}"${hint}`);
   }
 }
-var SDK_VERSION = "0.65.0" ;
+var SDK_VERSION = "0.67.0" ;
 var DEFAULT_API_URL = "https://api.warmhub.ai";
 var UNBATCHED_TRPC_PATHS = /* @__PURE__ */ new Set([
   "repo.shapeInstanceCounts",
@@ -9460,6 +9397,47 @@ function sanitizeSubscriptionUpdateInput(input) {
   } = input;
   return supported;
 }
+function hasCollectionQuerySource(source) {
+  return !!source && (!!source.shape || !!source.kind || !!source.about || !!source.match || !!source.componentRef || source.excludeComponents === true || (source.where?.length ?? 0) > 0);
+}
+function hasCollectionSelectorAnchor(source) {
+  return !!source && (!!source.shape || !!source.about || !!source.match || !!source.componentRef || (source.where?.length ?? 0) > 0);
+}
+function hasExplicitCollectionMembers(opts) {
+  const members = opts.members;
+  return Array.isArray(members) && members.length > 0;
+}
+function collectionTypeFromWref(wref) {
+  const local = wref.replace(/^wh:[^/]+\/[^/]+\//, "").replace(/@(?:HEAD|ALL|v\d+)$/, "");
+  const shape = local.split("/")[0]?.toLowerCase();
+  return shape === "pair" || shape === "set" || shape === "list" ? shape : void 0;
+}
+function assertSelectorBackedCollectionType(type, opts) {
+  if (hasCollectionQuerySource(opts.query) && !hasCollectionSelectorAnchor(opts.query)) {
+    throw new WarmHubError(
+      "VALIDATION_ERROR",
+      "Selector-backed collection sources require shape, about, match, componentRef, or where; kind and excludeComponents only narrow an existing selector."
+    );
+  }
+  if (opts.sourceRepo && !hasCollectionSelectorAnchor(opts.query)) {
+    throw new WarmHubError(
+      "VALIDATION_ERROR",
+      "sourceRepo requires a selector-backed collection query"
+    );
+  }
+  if (opts.sourceRepo && hasExplicitCollectionMembers(opts)) {
+    throw new WarmHubError(
+      "VALIDATION_ERROR",
+      "sourceRepo cannot be combined with explicit members; use canonical wh:org/repo/... member wrefs or omit sourceRepo."
+    );
+  }
+  if (hasCollectionQuerySource(opts.query) && type !== "set") {
+    throw new WarmHubError(
+      "VALIDATION_ERROR",
+      "Selector-backed collection sources are only supported for set collections"
+    );
+  }
+}
 function resolveFunctionLogMode(mode) {
   return mode ?? "off";
 }
@@ -10712,6 +10690,46 @@ var WarmHubClient = class _WarmHubClient {
         throw toWarmHubError(error);
       }
     },
+    /**
+     * Browse the public "Explore" directory: every `visibility='public'` live
+     * repository across all orgs, with search, org/activity/subscription/thing
+     * filters, and sort. No auth required — anonymous callers see the same
+     * public-only listing.
+     *
+     * Two mutually-exclusive modes. Browse mode paginates a filtered, sorted
+     * listing (`search`/`org`/`activity`/`hasSubscriptions`/`minThings`/`sort`/
+     * `limit`/`cursor`). Slugs mode is an exact-match batch lookup: pass up to
+     * 12 `org/repo` slugs to resolve just those live public repos in input
+     * order, ignoring every browse field. Combining `slugs` with any browse/
+     * search/sort/filter field is a hard input error, not a silently-filtered
+     * list.
+     *
+     * `total` and `orgs` (the org-filter facet) are returned on the first page
+     * only — i.e. when `cursor` is absent.
+     *
+     * Cursor contract: cursors are short-lived resume tokens for the same query
+     * and result scope. If filters, visibility, or backing streams change, the
+     * backend may reject a saved cursor with `VALIDATION_ERROR` / `Invalid
+     * cursor`; restart the query without `cursor` instead of retrying the stale
+     * token.
+     */
+    explore: async (opts) => {
+      try {
+        return await this.trpc.repo.explore.query({
+          search: opts?.search,
+          org: opts?.org,
+          activity: opts?.activity,
+          hasSubscriptions: opts?.hasSubscriptions,
+          minThings: opts?.minThings,
+          sort: opts?.sort,
+          limit: opts?.limit,
+          cursor: opts?.cursor,
+          slugs: opts?.slugs
+        });
+      } catch (error) {
+        throw toWarmHubError(error);
+      }
+    },
     /**
      * Fetch a repository's `Content/Readme` markdown record.
      *
@@ -11324,6 +11342,165 @@ var WarmHubClient = class _WarmHubClient {
       }
     }
   };
+  collection = {
+    create: async (orgName, repoName, opts) => {
+      try {
+        assertSelectorBackedCollectionType(opts.type, opts);
+        return await this.trpc.collection.create.mutate({
+          orgName,
+          repoName,
+          type: opts.type,
+          name: opts.name,
+          members: opts.members,
+          from: opts.from,
+          add: opts.add,
+          remove: opts.remove,
+          replaceMembers: opts.replaceMembers,
+          query: opts.query,
+          sourceOrgName: opts.sourceRepo?.orgName,
+          sourceRepoName: opts.sourceRepo?.repoName,
+          skipExisting: opts.skipExisting,
+          message: opts.message,
+          committer: opts.committer
+        });
+      } catch (error) {
+        throw toWarmHubError(error);
+      }
+    },
+    members: async (orgName, repoName, wref, opts) => {
+      try {
+        return await this.trpc.collection.members.query({
+          orgName,
+          repoName,
+          wref,
+          version: opts?.version,
+          limit: opts?.limit,
+          cursor: opts?.cursor
+        });
+      } catch (error) {
+        throw toWarmHubError(error);
+      }
+    },
+    membersIter: (orgName, repoName, wref, opts) => {
+      let snapshotVersion = opts?.version;
+      return paginate(
+        async (cursor) => {
+          const page = await this.collection.members(orgName, repoName, wref, {
+            ...opts,
+            version: snapshotVersion,
+            cursor
+          });
+          snapshotVersion ??= page.version;
+          return page;
+        },
+        (page) => page.items,
+        opts?.cursor
+      );
+    },
+    membersAll: async (orgName, repoName, wref, opts) => {
+      const { max, ...pageOpts } = opts ?? {};
+      let snapshotVersion = pageOpts.version;
+      return await collectPaginatedPages(
+        async (cursor) => {
+          const page = await this.collection.members(orgName, repoName, wref, {
+            ...pageOpts,
+            version: snapshotVersion,
+            cursor
+          });
+          snapshotVersion ??= page.version;
+          return page;
+        },
+        (page) => page.items,
+        max,
+        pageOpts.cursor
+      );
+    },
+    contains: async (orgName, repoName, wref, members, opts) => {
+      try {
+        return await this.trpc.collection.contains.query({
+          orgName,
+          repoName,
+          wref,
+          version: opts?.version,
+          members,
+          position: opts?.position
+        });
+      } catch (error) {
+        throw toWarmHubError(error);
+      }
+    },
+    diff: async (orgName, repoName, leftWref, rightWref, opts) => {
+      try {
+        return await this.trpc.collection.diff.query({
+          orgName,
+          repoName,
+          leftWref,
+          rightWref,
+          leftVersion: opts?.leftVersion,
+          rightVersion: opts?.rightVersion,
+          mode: opts?.mode
+        });
+      } catch (error) {
+        throw toWarmHubError(error);
+      }
+    },
+    revise: async (orgName, repoName, wref, opts) => {
+      try {
+        const targetType = collectionTypeFromWref(wref);
+        if (hasCollectionQuerySource(opts.query) && !hasCollectionSelectorAnchor(opts.query)) {
+          throw new WarmHubError(
+            "VALIDATION_ERROR",
+            "Selector-backed collection sources require shape, about, match, componentRef, or where; kind and excludeComponents only narrow an existing selector."
+          );
+        }
+        if (opts.sourceRepo && !hasCollectionSelectorAnchor(opts.query)) {
+          throw new WarmHubError(
+            "VALIDATION_ERROR",
+            "sourceRepo requires a selector-backed collection query"
+          );
+        }
+        if (opts.sourceRepo && hasExplicitCollectionMembers(opts)) {
+          throw new WarmHubError(
+            "VALIDATION_ERROR",
+            "sourceRepo cannot be combined with explicit members; use canonical wh:org/repo/... member wrefs or omit sourceRepo."
+          );
+        }
+        if (hasCollectionQuerySource(opts.query) && targetType && targetType !== "set") {
+          throw new WarmHubError(
+            "VALIDATION_ERROR",
+            "Selector-backed revise requires a Set/<name> target wref"
+          );
+        }
+        return await this.trpc.collection.revise.mutate({
+          orgName,
+          repoName,
+          wref,
+          members: opts.members,
+          add: opts.add,
+          remove: opts.remove,
+          query: opts.query,
+          sourceOrgName: opts.sourceRepo?.orgName,
+          sourceRepoName: opts.sourceRepo?.repoName,
+          message: opts.message,
+          committer: opts.committer
+        });
+      } catch (error) {
+        throw toWarmHubError(error);
+      }
+    },
+    stats: async (orgName, repoName, wref, opts) => {
+      try {
+        return await this.trpc.collection.stats.query({
+          orgName,
+          repoName,
+          wref,
+          version: opts?.version
+        });
+      } catch (error) {
+        throw toWarmHubError(error);
+      }
+    }
+  };
   /**
    * Read surface for things, assertions, histories, references, search, and in-place thing renames.
    */
@@ -11406,6 +11583,7 @@ var WarmHubClient = class _WarmHubClient {
      *
      * @param version Optional exact version to pin when the wref is not already version-qualified.
      * @param opts.includeRetracted Include retracted records instead of treating them as missing.
+     * @param opts.dataMode Defaults to `auto`; pass `full` to force full collection bodies.
      */
     get: async (orgName, repoName, wref, version, opts) => {
       try {
@@ -11414,7 +11592,8 @@ var WarmHubClient = class _WarmHubClient {
           repoName,
           wref,
           version,
-          includeRetracted: opts?.includeRetracted
+          includeRetracted: opts?.includeRetracted,
+          dataMode: opts?.dataMode
         });
       } catch (error) {
         throw toWarmHubError(error);
@@ -11524,7 +11703,8 @@ var WarmHubClient = class _WarmHubClient {
             repoName,
             wrefs: chunkWrefs,
             version,
-            includeRetracted: opts?.includeRetracted
+            includeRetracted: opts?.includeRetracted,
+            dataMode: opts?.dataMode
           });
         };
         if (wrefs.length <= chunkSize) {
@@ -11844,7 +12024,8 @@ var WarmHubClient = class _WarmHubClient {
           componentRef: opts?.componentRef,
           excludeComponents: opts?.excludeComponents,
           excludeInfraShapes: opts?.excludeInfraShapes,
-          mode: opts?.mode
+          mode: opts?.mode,
+          nameMatch: opts?.nameMatch
         });
       } catch (error) {
         throw toWarmHubError(error);
@@ -12135,7 +12316,7 @@ var WarmHubClient = class _WarmHubClient {
     /**
      * Append one non-empty chunk of stream operations to a repository.
      *
-     * Most callers should prefer `commit.apply` or `OperationBuilder`. Use this low-level surface only when you already have stream operations, a stream ID, and any allocated `$N` / `#N` token state you need to continue.
+     * Most callers should prefer `commit.apply` or `OperationBuilder`. Use this low-level surface only when you already have backend-shaped stream operations and a caller-managed stream ID.
      */
     append: async (input) => {
       try {
@@ -12630,5 +12811,5 @@ re2js/build/index.js:
 */
 
 export { AllStreamOperationsFailedError, CLI_INSTALL_REPO_HEADER, CLI_SIGNATURE_HEADER, CLI_TIMESTAMP_HEADER, CONTENT_FIELD_LIMIT_ERROR, CliCallVerificationError, DEFAULT_API_URL, DEFAULT_STREAM_CHUNK_SIZE, MAX_CONTENT_FIELD_BYTES, MAX_STREAM_APPEND_OPERATION_COUNT2 as MAX_STREAM_APPEND_OPERATION_COUNT, OperationBuilder, PartialStreamSubmissionError, SDK_VERSION, WarmHubClient, WarmHubError, connectionErrorMessage, contentFieldLimitError, countStreamAppendResultStatuses, isConnectionError, isRetryable, isWarmHubError, normalizeWref, resolveFunctionLogMode, sanitizeErrorMessage, sdkVersionIsBelowMinimum, streamAppendResultStatus, submitOperationsViaStream, toWarmHubError, validateAgainstShape, verifyCliCall };
-//# sourceMappingURL=chunk-C2Q4D3JM.js.map
-//# sourceMappingURL=chunk-C2Q4D3JM.js.map
+//# sourceMappingURL=chunk-2KN2JWJU.js.map
+//# sourceMappingURL=chunk-2KN2JWJU.js.map