@warmhub/sdk-ts 0.60.1 → 0.61.0

package/dist/{chunk-D5A5SSUU.js → chunk-QS6ABKPJ.js}

@@ -17,6 +17,13 @@ function isBuiltinShape(name) {
   return BUILTIN_SHAPE_NAMES.includes(name) || BUILTIN_CONTENT_SHAPE_NAMES.includes(name);
 }
 
+// ../rules/src/client-header.ts
+var CLIENT_HEADER = "X-WarmHub-Client";
+var WARMHUB_SDK_CLIENT_NAME = "@warmhub/sdk-ts";
+function formatClientHeader(name, version) {
+  return `${name}/${version}`;
+}
+
 // ../rules/src/commit-stream-limits.ts
 var DEFAULT_STREAM_APPEND_CHUNK_SIZE = 1e3;
 var MAX_STREAM_APPEND_OPERATION_COUNT = 1e4;
@@ -190,7 +197,7 @@ var REPO_AUTH_SCOPES = [
   "repo:action-callback"
 ];
 
-// ../rules/src/component-manifest-contract.ts
+// ../rules/src/component-manifest-contract-internals.ts
 new Set(REPO_AUTH_SCOPES);
 
 // ../rules/src/field-name-safety.ts
@@ -378,183 +385,13 @@ function hasAnyTokens(s) {
   return ANY_TOKEN_RE.test(s);
 }
 
-// ../rules/src/preflight.ts
-var collectionTypes = ["pair", "triple", "set", "list"];
-var collectionOps = ["add", "revise"];
-function preflightOpDiagnostics(op, operationIndex) {
-  const errors = [];
-  errors.push(...builtinShapeGuard(op, operationIndex));
-  errors.push(...contentNameGuard(op, operationIndex));
-  errors.push(...plusSignGuard(op, operationIndex));
-  errors.push(...validateCollectionAbouts(op, operationIndex));
-  errors.push(...validateCollectionOps(op, operationIndex));
-  return errors;
-}
-function builtinShapeGuard(op, operationIndex) {
-  const errors = [];
-  const name = op.name;
-  if (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) {
-    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.`;
-      errors.push({
-        code: "VALIDATION_ERROR",
-        operationIndex,
-        message
-      });
-    }
-  }
-  return errors;
-}
-function contentNameGuard(op, operationIndex) {
-  if (op.kind !== "thing" || !op.name) return [];
-  const local = splitLocalPath(op.name);
-  if (!local || !isContentShape(local.shapePrefix)) return [];
-  const bareName = local.bareName;
-  if (isSynthesizedContentName(bareName)) {
-    return [
-      {
-        code: "READ_ONLY_BUILTIN_CONTENT",
-        operationIndex,
-        message: `${local.shapePrefix}/${bareName} is synthesized; writes are not allowed`
-      }
-    ];
-  }
-  if (!isStoredContentName(bareName)) {
-    return [
-      {
-        code: "UNKNOWN_CONTENT_NAME",
-        operationIndex,
-        message: `${local.shapePrefix}/${bareName} is not a recognized well-known content name`
-      }
-    ];
-  }
-  return [];
-}
-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;
-    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}`
-    });
-    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") {
-      errors.push({
-        code: "VALIDATION_ERROR",
-        operationIndex,
-        message: `Collection member at index ${i} must be a string, got ${typeof members[i]}`
-      });
-    }
-  }
-  const arityError = collectionArityError(tag, members);
-  if (arityError) {
-    errors.push({
-      code: "VALIDATION_ERROR",
-      operationIndex,
-      message: arityError
-    });
-  }
-  return errors;
-}
-function validateCollectionOps(op, operationIndex) {
-  const errors = [];
-  if (op.kind !== "collection") return errors;
-  if (!collectionOps.includes(op.operation)) {
-    errors.push({
-      code: "VALIDATION_ERROR",
-      operationIndex,
-      message: `Collection kind only supports "add" or "revise" operation, got "${op.operation}"`
-    });
-    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) {
-        errors.push({
-          code: "VALIDATION_ERROR",
-          operationIndex,
-          message: arityError
-        });
-      }
-    }
-  }
-  return errors;
-}
+// ../rules/src/preflight-commit.ts
 function preflightCommitDiagnostics(operations, options) {
   const errors = [];
   tokenHygiene(operations, errors);
   illegalOpSequences(operations, errors);
   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;
-  }
-}
 function getOpName(op) {
   return op.name;
 }
@@ -727,59 +564,239 @@ function illegalOpSequences(operations, errors, checkAddAdd) {
   }
 }
 
-// ../rules/src/reserved-orgs.ts
-var RESERVED_RAW_CONTENT_TOP_LEVEL_NAMES = [
-  "_app",
-  "_static",
-  "api",
-  "health",
-  "healthz",
-  "mcp",
-  "readyz",
-  "robots.txt",
-  "sse",
-  "trpc",
-  "version"
-];
-var RESERVED_ORG_NAMES = [
-  ...RESERVED_RAW_CONTENT_TOP_LEVEL_NAMES,
-  "admin",
-  "billing",
-  "blog",
-  "docs",
-  "help",
-  "login",
-  "public",
-  "settings",
-  "signup",
-  "status",
-  "support",
-  "system",
-  "warmhub",
-  "www"
-];
-new Set(RESERVED_ORG_NAMES);
-
-// ../rules/src/shape-field-key.ts
-function foldFieldName(name) {
-  const stripped = name.endsWith("?") ? name.slice(0, -1) : name;
-  return stripped.toLowerCase();
+// ../rules/src/preflight-operation.ts
+var collectionTypes = ["pair", "triple", "set", "list"];
+var collectionOps = ["add", "revise"];
+function preflightOpDiagnostics(op, operationIndex) {
+  const errors = [];
+  errors.push(...builtinShapeGuard(op, operationIndex));
+  errors.push(...contentNameGuard(op, operationIndex));
+  errors.push(...plusSignGuard(op, operationIndex));
+  errors.push(...validateCollectionAbouts(op, operationIndex));
+  errors.push(...validateCollectionOps(op, operationIndex));
+  return errors;
 }
-function foldFieldPath(path) {
-  return path.split(".").map((segment) => foldFieldName(segment)).join(".");
+function builtinShapeGuard(op, operationIndex) {
+  const errors = [];
+  const name = op.name;
+  if (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) {
+    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.`;
+      errors.push({
+        code: "VALIDATION_ERROR",
+        operationIndex,
+        message
+      });
+    }
+  }
+  return errors;
 }
-
-// ../rules/src/shape-types.ts
-var BASE_PRIMITIVE_TYPES = [
-  "number",
-  "string",
-  "boolean",
-  "wref",
-  "array"
-];
-var BASE_PRIMITIVE_TYPE_SET = new Set(BASE_PRIMITIVE_TYPES);
-var VALID_PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
-  "number",
+function contentNameGuard(op, operationIndex) {
+  if (op.kind !== "thing" || !op.name) return [];
+  const local = splitLocalPath(op.name);
+  if (!local || !isContentShape(local.shapePrefix)) return [];
+  const bareName = local.bareName;
+  if (isSynthesizedContentName(bareName)) {
+    return [
+      {
+        code: "READ_ONLY_BUILTIN_CONTENT",
+        operationIndex,
+        message: `${local.shapePrefix}/${bareName} is synthesized; writes are not allowed`
+      }
+    ];
+  }
+  if (!isStoredContentName(bareName)) {
+    return [
+      {
+        code: "UNKNOWN_CONTENT_NAME",
+        operationIndex,
+        message: `${local.shapePrefix}/${bareName} is not a recognized well-known content name`
+      }
+    ];
+  }
+  return [];
+}
+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;
+    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}`
+    });
+    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") {
+      errors.push({
+        code: "VALIDATION_ERROR",
+        operationIndex,
+        message: `Collection member at index ${i} must be a string, got ${typeof members[i]}`
+      });
+    }
+  }
+  const arityError = collectionArityError(tag, members);
+  if (arityError) {
+    errors.push({
+      code: "VALIDATION_ERROR",
+      operationIndex,
+      message: arityError
+    });
+  }
+  return errors;
+}
+function validateCollectionOps(op, operationIndex) {
+  const errors = [];
+  if (op.kind !== "collection") return errors;
+  if (!collectionOps.includes(op.operation)) {
+    errors.push({
+      code: "VALIDATION_ERROR",
+      operationIndex,
+      message: `Collection kind only supports "add" or "revise" operation, got "${op.operation}"`
+    });
+    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) {
+        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;
+  }
+}
+
+// ../rules/src/preflight.ts
+function preflightOpDiagnostics2(op, operationIndex) {
+  return preflightOpDiagnostics(op, operationIndex);
+}
+function preflightCommitDiagnostics2(operations, options) {
+  return preflightCommitDiagnostics(operations);
+}
+
+// ../rules/src/reserved-orgs.ts
+var RESERVED_RAW_CONTENT_TOP_LEVEL_NAMES = [
+  "_app",
+  "_static",
+  "api",
+  "health",
+  "healthz",
+  "mcp",
+  "readyz",
+  "robots.txt",
+  "sse",
+  "trpc",
+  "version"
+];
+var RESERVED_ORG_NAMES = [
+  ...RESERVED_RAW_CONTENT_TOP_LEVEL_NAMES,
+  "admin",
+  "billing",
+  "blog",
+  "docs",
+  "help",
+  "login",
+  "public",
+  "settings",
+  "signup",
+  "status",
+  "support",
+  "system",
+  "warmhub",
+  "www"
+];
+new Set(RESERVED_ORG_NAMES);
+
+// ../rules/src/shape-field-key.ts
+function foldFieldName(name) {
+  const stripped = name.endsWith("?") ? name.slice(0, -1) : name;
+  return stripped.toLowerCase();
+}
+function foldFieldPath(path) {
+  return path.split(".").map((segment) => foldFieldName(segment)).join(".");
+}
+
+// ../rules/src/shape-types.ts
+var BASE_PRIMITIVE_TYPES = [
+  "number",
+  "string",
+  "boolean",
+  "wref",
+  "array"
+];
+var BASE_PRIMITIVE_TYPE_SET = new Set(BASE_PRIMITIVE_TYPES);
+var VALID_PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
+  "number",
   "string",
   "boolean",
   "wref",
@@ -7129,7 +7146,7 @@ var RE2JS = class RE2JS2 {
   }
 };
 
-// ../rules/src/shape-validation.ts
+// ../rules/src/shape-validation-types.ts
 var MAX_CONTENT_FIELD_BYTES = 64 * 1024;
 var MAX_INDEXABLE_SCALAR_FIELDS_PER_SHAPE = 256;
 var UNSUPPORTED_REGEX_SYNTAX_REASON = "uses unsupported regex syntax";
@@ -7206,162 +7223,301 @@ function normalizeOptionalTypeSpec(spec) {
   }
   return { spec, optionalByType: false };
 }
-function validationContext(options = {}) {
-  return {
-    allowUnsafeFieldNamePaths: new Set(options.allowUnsafeFieldNamePaths ?? [])
-  };
-}
-function isAllowedLegacyUnsafeFieldPath(context, path) {
-  return context.allowUnsafeFieldNamePaths.has(path);
+
+// ../rules/src/shape-validation-runtime.ts
+function validateAgainstShape(data, shapeFields) {
+  return compileShapeValidator(shapeFields)(data);
 }
-function validateTypedFieldObject(path, identityPath, spec, errors, context) {
-  const typeValue = spec.type;
-  if (typeof typeValue !== "string") {
-    errors.push(
-      `Invalid typed field object at "${path}": "type" must be a string`
-    );
-    return;
+function declaredFieldNames(shapeFields) {
+  const declared = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(shapeFields)) {
+    declared.add(key.endsWith("?") ? key.slice(0, -1) : key);
   }
-  if (!VALID_PRIMITIVE_TYPES.has(typeValue)) {
-    errors.push(
-      `Invalid type at "${path}.type": "${escapeFieldNameForDisplay(typeValue)}" (expected number|string|boolean|wref|array, optionally with ? suffix)`
-    );
-    return;
+  return declared;
+}
+function buildUndeclaredFieldsWarningFromDeclaredSet(data, declared) {
+  const undeclaredFields = [];
+  let totalUndeclared = 0;
+  for (const key of Object.keys(data)) {
+    if (declared.has(key)) continue;
+    totalUndeclared++;
+    if (undeclaredFields.length < MAX_UNDECLARED_FIELDS_REPORTED) {
+      undeclaredFields.push(key);
+    }
   }
-  if ("description" in spec && typeof spec.description !== "string") {
-    errors.push(
-      `Invalid typed field object at "${path}": "description" must be a string`
-    );
+  if (totalUndeclared === 0) return void 0;
+  if (totalUndeclared > MAX_UNDECLARED_FIELDS_REPORTED) {
+    return {
+      undeclaredFields,
+      undeclaredFieldsTruncated: true,
+      totalUndeclared
+    };
   }
-  const baseType = typeValue.endsWith("?") ? typeValue.slice(0, -1) : typeValue;
-  for (const key of Object.keys(spec)) {
-    if (key === "type" || key === "description") continue;
-    const safeKey = escapeFieldNameForDisplay(key);
-    if (baseType === "string") {
-      if (!STRING_CONSTRAINT_KEYS.has(key)) {
-        errors.push(
-          `Constraint "${safeKey}" at "${path}" is not valid for type "string"`
-        );
-      }
-    } else if (baseType === "number") {
-      if (!NUMBER_CONSTRAINT_KEYS.has(key)) {
-        errors.push(
-          `Constraint "${safeKey}" at "${path}" is not valid for type "number"`
-        );
-      }
-    } else if (baseType === "wref") {
-      if (!WREF_CONSTRAINT_KEYS.has(key)) {
-        errors.push(
-          `Constraint "${safeKey}" at "${path}" is not valid for type "wref"`
-        );
-      }
-    } else if (baseType === "array") {
-      if (!ARRAY_CONSTRAINT_KEYS.has(key)) {
-        errors.push(
-          `Constraint "${safeKey}" at "${path}" is not valid for type "array"`
-        );
+  return { undeclaredFields };
+}
+var MAX_UNDECLARED_FIELDS_REPORTED = 500;
+function compileShapeValidator(shapeFields) {
+  const compiledFields = compileObjectFields(shapeFields);
+  const declared = declaredFieldNames(shapeFields);
+  return (data) => {
+    const errors = [];
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+      return { valid: false, errors: ["Data must be a plain object"] };
+    }
+    for (const field of compiledFields) {
+      const value = data[field.fieldName];
+      if (value === void 0 || value === null) {
+        if (!field.isOptional) {
+          errors.push(`Missing required field: "${field.displayName}"`);
+        }
+        continue;
       }
-    } else {
-      errors.push(
-        `Constraint "${safeKey}" at "${path}" is not valid for type "${baseType}"`
-      );
+      field.validate(field.displayName, value, errors);
     }
+    validatePersistedStringFieldLimits(data, shapeFields, errors);
+    const warnings = buildUndeclaredFieldsWarningFromDeclaredSet(data, declared);
+    if (errors.length > 0) {
+      return warnings ? { valid: false, errors, warnings } : { valid: false, errors };
+    }
+    return warnings ? { valid: true, warnings } : { valid: true };
+  };
+}
+function validatePersistedStringFieldLimits(value, typeDef, errors, path) {
+  const normalized = normalizeOptionalTypeSpec(typeDef).spec;
+  if (typeof value === "string") {
+    if (isDeclaredStringType(normalized) || isDeclaredWrefType(normalized))
+      return;
+    if (normalized !== void 0) return;
+    assertContentFieldWithinLimit(path ?? "<value>", value, errors);
+    return;
   }
-  if ("minLength" in spec && (typeof spec.minLength !== "number" || !Number.isFinite(spec.minLength) || spec.minLength < 0 || !Number.isInteger(spec.minLength))) {
-    errors.push(
-      `"minLength" at "${path}" must be a non-negative finite integer`
-    );
+  if (Array.isArray(value)) {
+    const elementType = arrayElementType(normalized);
+    if (normalized !== void 0 && elementType === void 0) return;
+    for (let i = 0; i < value.length; i++) {
+      validatePersistedStringFieldLimits(
+        value[i],
+        elementType,
+        errors,
+        `${path ?? "<value>"}[${i}]`
+      );
+    }
+    return;
   }
-  if ("maxLength" in spec && (typeof spec.maxLength !== "number" || !Number.isFinite(spec.maxLength) || spec.maxLength < 0 || !Number.isInteger(spec.maxLength))) {
-    errors.push(
-      `"maxLength" at "${path}" must be a non-negative finite integer`
+  if (!isPlainObject(value)) return;
+  const fields = nestedObjectFields(normalized);
+  if (normalized !== void 0 && fields === void 0) return;
+  for (const [key, nestedValue] of Object.entries(value)) {
+    validatePersistedStringFieldLimits(
+      nestedValue,
+      fields?.get(key),
+      errors,
+      path ? joinFieldPath(path, key) : escapeFieldNameForDisplay(key)
     );
   }
-  if ("minLength" in spec && "maxLength" in spec && typeof spec.minLength === "number" && typeof spec.maxLength === "number" && spec.minLength > spec.maxLength) {
-    errors.push(`"minLength" at "${path}" cannot exceed "maxLength"`);
+}
+function isDeclaredStringType(typeDef) {
+  if (typeDef === "string") return true;
+  return isTypeSpecObject(typeDef) && typeDef.type === "string";
+}
+function isDeclaredWrefType(typeDef) {
+  if (typeDef === "wref") return true;
+  return isTypeSpecObject(typeDef) && typeDef.type === "wref";
+}
+function arrayElementType(typeDef) {
+  if (Array.isArray(typeDef)) return typeDef[0];
+  if (isTypeSpecObject(typeDef) && typeDef.type === "array")
+    return typeDef.items;
+  return void 0;
+}
+function nestedObjectFields(typeDef) {
+  if (!isPlainObject(typeDef) || isTypeSpecObject(typeDef)) return void 0;
+  const fields = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(typeDef)) {
+    fields.set(key.endsWith("?") ? key.slice(0, -1) : key, value);
   }
-  if (baseType === "string" && typeof spec.minLength === "number" && Number.isFinite(spec.minLength) && Number.isInteger(spec.minLength) && spec.minLength > MAX_CONTENT_FIELD_BYTES) {
-    errors.push(
-      `"minLength" at "${path}" cannot exceed ${MAX_CONTENT_FIELD_BYTES}`
-    );
+  return fields;
+}
+function compileObjectFields(shapeFields) {
+  return Object.entries(shapeFields).map(([fieldSpec, rawTypeDef]) => {
+    const isOptionalByKey = fieldSpec.endsWith("?");
+    const fieldName = isOptionalByKey ? fieldSpec.slice(0, -1) : fieldSpec;
+    const normalized = normalizeOptionalTypeSpec(rawTypeDef);
+    return {
+      fieldName,
+      displayName: escapeFieldNameForDisplay(fieldName),
+      isOptional: isOptionalByKey || normalized.optionalByType,
+      validate: compileTypeValidator(normalized.spec)
+    };
+  });
+}
+function compileTypeValidator(typeDef) {
+  if (typeof typeDef === "string") {
+    return (path, value, errors) => validatePrimitiveField(path, value, typeDef, errors);
   }
-  if (baseType === "string" && typeof spec.maxLength === "number" && Number.isFinite(spec.maxLength) && Number.isInteger(spec.maxLength) && spec.maxLength > MAX_CONTENT_FIELD_BYTES) {
-    errors.push(
-      `"maxLength" at "${path}" cannot exceed ${MAX_CONTENT_FIELD_BYTES}`
-    );
+  if (Array.isArray(typeDef)) {
+    const elementValidator = typeDef.length > 0 ? compileTypeValidator(normalizeOptionalTypeSpec(typeDef[0]).spec) : void 0;
+    return (path, value, errors) => {
+      if (!Array.isArray(value)) {
+        errors.push(`Field "${path}" expected array, got ${typeof value}`);
+      } else if (elementValidator) {
+        for (let i = 0; i < value.length; i++) {
+          elementValidator(`${path}[${i}]`, value[i], errors);
+        }
+      }
+    };
   }
-  if ("pattern" in spec && typeof spec.pattern !== "string") {
-    errors.push(`"pattern" at "${path}" must be a string`);
+  if (isTypeSpecObject(typeDef)) {
+    const baseType = typeDef.type.endsWith("?") ? typeDef.type.slice(0, -1) : typeDef.type;
+    if (baseType === "array") {
+      const elementValidator = "items" in typeDef && typeDef.items != null ? compileTypeValidator(normalizeOptionalTypeSpec(typeDef.items).spec) : void 0;
+      return (path, value, errors) => {
+        if (!Array.isArray(value)) {
+          errors.push(`Field "${path}" expected array, got ${typeof value}`);
+          return;
+        }
+        if (typeof typeDef.minItems === "number" && value.length < typeDef.minItems) {
+          errors.push(
+            `Field "${path}" has ${value.length} items, minimum is ${typeDef.minItems}`
+          );
+        }
+        if (typeof typeDef.maxItems === "number" && value.length > typeDef.maxItems) {
+          errors.push(
+            `Field "${path}" has ${value.length} items, maximum is ${typeDef.maxItems}`
+          );
+        }
+        if (elementValidator) {
+          for (let i = 0; i < value.length; i++) {
+            elementValidator(`${path}[${i}]`, value[i], errors);
+          }
+        }
+      };
+    }
+    const validateConstraintsCompiled = compileConstraintsValidator(typeDef);
+    return (path, value, errors) => {
+      validatePrimitiveField(path, value, typeDef.type, errors);
+      validateConstraintsCompiled(path, value, errors);
+    };
   }
-  if ("pattern" in spec && typeof spec.pattern === "string") {
-    if (nativeRegexSyntaxError(spec.pattern)) {
-      errors.push(`"pattern" at "${path}" is not a valid regular expression`);
-    } else {
-      const unsupportedReason = unsupportedPortablePatternReason(spec.pattern);
-      if (unsupportedReason) {
-        errors.push(`"pattern" at "${path}" ${unsupportedReason}`);
+  if (isPlainObject(typeDef)) {
+    const compiledFields = compileObjectFields(typeDef);
+    return (path, value, errors) => {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        errors.push(`Field "${path}" expected object, got ${typeof value}`);
+        return;
       }
-    }
+      const objValue = value;
+      for (const field of compiledFields) {
+        const subValue = objValue[field.fieldName];
+        const subPath = joinFieldPath(path, field.fieldName);
+        if (subValue === void 0 || subValue === null) {
+          if (!field.isOptional) {
+            errors.push(`Missing required field: "${subPath}"`);
+          }
+          continue;
+        }
+        field.validate(subPath, subValue, errors);
+      }
+    };
   }
-  if ("enum" in spec) {
-    if (!Array.isArray(spec.enum) || spec.enum.length === 0 || !spec.enum.every((v) => typeof v === "string")) {
-      errors.push(`"enum" at "${path}" must be a non-empty array of strings`);
-    } else if (baseType === "string") {
-      for (const value of spec.enum) {
-        const byteLength = utf8ByteLength(value);
-        if (byteLength > MAX_CONTENT_FIELD_BYTES) {
+  return () => {
+  };
+}
+function compileConstraintsValidator(spec) {
+  const pattern = typeof spec.pattern === "string" ? spec.pattern : void 0;
+  const patternConstraint = pattern === void 0 ? void 0 : compilePatternConstraint(pattern);
+  return (path, value, errors) => {
+    if (typeof value === "string") {
+      if (typeof spec.minLength === "number" && value.length < spec.minLength) {
+        errors.push(
+          `Field "${path}" length ${value.length} is below minimum ${spec.minLength}`
+        );
+      }
+      if (typeof spec.maxLength === "number" && value.length > spec.maxLength) {
+        errors.push(
+          `Field "${path}" length ${value.length} exceeds maximum ${spec.maxLength}`
+        );
+      }
+      if (pattern !== void 0) {
+        const safePattern = escapeFieldNameForDisplay(pattern);
+        if (patternConstraint?.kind === "unsupported") {
           errors.push(
-            `"enum" value at "${path}" is ${byteLength} bytes; string enum values cannot exceed ${MAX_CONTENT_FIELD_BYTES} bytes`
+            `Field "${path}" has unsupported pattern "${safePattern}"`
           );
-          break;
+        } else if (patternConstraint?.kind === "invalid") {
+          errors.push(
+            `Field "${path}" has invalid pattern "${safePattern}" \u2014 skipping regex check`
+          );
+        } else if (patternConstraint?.kind === "compiled" && !patternConstraint.regex.test(value)) {
+          errors.push(`Field "${path}" does not match pattern "${safePattern}"`);
         }
       }
+      if (Array.isArray(spec.enum) && !spec.enum.includes(value)) {
+        errors.push(
+          `Field "${path}" value "${escapeFieldNameForDisplay(String(value))}" is not in allowed values: ${spec.enum.map((entry) => escapeFieldNameForDisplay(String(entry))).join(", ")}`
+        );
+      }
     }
-  }
-  if ("minimum" in spec && (typeof spec.minimum !== "number" || !Number.isFinite(spec.minimum))) {
-    errors.push(`"minimum" at "${path}" must be a finite number`);
-  }
-  if ("maximum" in spec && (typeof spec.maximum !== "number" || !Number.isFinite(spec.maximum))) {
-    errors.push(`"maximum" at "${path}" must be a finite number`);
-  }
-  if ("minimum" in spec && "maximum" in spec && typeof spec.minimum === "number" && typeof spec.maximum === "number" && spec.minimum > spec.maximum) {
-    errors.push(`"minimum" at "${path}" cannot exceed "maximum"`);
-  }
-  if ("integer" in spec && typeof spec.integer !== "boolean") {
-    errors.push(`"integer" at "${path}" must be a boolean`);
-  }
-  if ("shape" in spec) {
-    if (typeof spec.shape !== "string") {
-      errors.push(`"shape" at "${path}" must be a string (shape name)`);
-    } else if (spec.shape === "") {
-      errors.push(`"shape" at "${path}" must not be empty`);
+    if (typeof value === "number") {
+      if (typeof spec.minimum === "number" && value < spec.minimum) {
+        errors.push(
+          `Field "${path}" value ${value} is below minimum ${spec.minimum}`
+        );
+      }
+      if (typeof spec.maximum === "number" && value > spec.maximum) {
+        errors.push(
+          `Field "${path}" value ${value} exceeds maximum ${spec.maximum}`
+        );
+      }
+      if (spec.integer === true && !Number.isInteger(value)) {
+        errors.push(`Field "${path}" must be an integer, got ${value}`);
+      }
     }
+  };
+}
+function compilePatternConstraint(pattern) {
+  if (nativeRegexSyntaxError(pattern)) {
+    return { kind: "invalid" };
   }
-  if ("minItems" in spec && (typeof spec.minItems !== "number" || !Number.isFinite(spec.minItems) || spec.minItems < 0 || !Number.isInteger(spec.minItems))) {
-    errors.push(`"minItems" at "${path}" must be a non-negative finite integer`);
-  }
-  if ("maxItems" in spec && (typeof spec.maxItems !== "number" || !Number.isFinite(spec.maxItems) || spec.maxItems < 0 || !Number.isInteger(spec.maxItems))) {
-    errors.push(`"maxItems" at "${path}" must be a non-negative finite integer`);
-  }
-  if ("minItems" in spec && "maxItems" in spec && typeof spec.minItems === "number" && typeof spec.maxItems === "number" && spec.minItems > spec.maxItems) {
-    errors.push(`"minItems" at "${path}" cannot exceed "maxItems"`);
-  }
-  if (baseType === "array") {
-    if (!("items" in spec)) {
-      errors.push(
-        `Typed array at "${path}" must have an "items" key specifying the element type`
-      );
-    } else {
-      validateTypeSpec(
-        `${path}.items`,
-        `${identityPath}.items`,
-        spec.items,
-        errors,
-        context
-      );
-    }
+  const regex = compilePortablePattern(pattern);
+  return regex ? { kind: "compiled", regex } : { kind: "unsupported" };
+}
+function validatePrimitiveField(path, value, typeDef, errors) {
+  switch (typeDef) {
+    case "number":
+      if (typeof value !== "number") {
+        errors.push(`Field "${path}" expected number, got ${typeof value}`);
+      }
+      break;
+    case "string":
+      if (typeof value !== "string") {
+        errors.push(`Field "${path}" expected string, got ${typeof value}`);
+      } else {
+        assertContentFieldWithinLimit(path, value, errors);
+      }
+      break;
+    case "wref":
+      if (typeof value !== "string") {
+        errors.push(`Field "${path}" expected string, got ${typeof value}`);
+      }
+      break;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        errors.push(`Field "${path}" expected boolean, got ${typeof value}`);
+      }
+      break;
+    case "array":
+      if (!Array.isArray(value)) {
+        errors.push(`Field "${path}" expected array, got ${typeof value}`);
+      }
+      break;
   }
 }
+
+// ../rules/src/shape-validation-type-spec.ts
+function isAllowedLegacyUnsafeFieldPath(context, path) {
+  return context.allowUnsafeFieldNamePaths.has(path);
+}
 function validateTypeSpec(path, identityPath, spec, errors, context) {
   if (typeof spec === "string") {
     if (!VALID_PRIMITIVE_TYPES.has(spec)) {
@@ -7452,22 +7608,180 @@ function validateTypeSpec(path, identityPath, spec, errors, context) {
         return;
       }
     }
-    for (const [key, value] of Object.entries(spec)) {
-      const bareKey = stripOptionalMarker(key);
-      const verdict = isUnsafeFieldName(bareKey);
-      const fieldPath = joinFieldPath(path, key);
-      const fieldIdentityPath = joinFieldIdentityPath(identityPath, key);
-      if (verdict.unsafe && !isAllowedLegacyUnsafeFieldPath(context, fieldIdentityPath)) {
-        errors.push(`Invalid field name at "${fieldPath}": ${verdict.reason}`);
-        continue;
-      }
-      validateTypeSpec(fieldPath, fieldIdentityPath, value, errors, context);
+    for (const [key, value] of Object.entries(spec)) {
+      const bareKey = stripOptionalMarker(key);
+      const verdict = isUnsafeFieldName(bareKey);
+      const fieldPath = joinFieldPath(path, key);
+      const fieldIdentityPath = joinFieldIdentityPath(identityPath, key);
+      if (verdict.unsafe && !isAllowedLegacyUnsafeFieldPath(context, fieldIdentityPath)) {
+        errors.push(`Invalid field name at "${fieldPath}": ${verdict.reason}`);
+        continue;
+      }
+      validateTypeSpec(fieldPath, fieldIdentityPath, value, errors, context);
+    }
+    return;
+  }
+  errors.push(
+    `Invalid type at "${path}": expected string, array, or object, got ${typeof spec}`
+  );
+}
+function validateTypedFieldObject(path, identityPath, spec, errors, context) {
+  const typeValue = spec.type;
+  if (typeof typeValue !== "string") {
+    errors.push(
+      `Invalid typed field object at "${path}": "type" must be a string`
+    );
+    return;
+  }
+  if (!VALID_PRIMITIVE_TYPES.has(typeValue)) {
+    errors.push(
+      `Invalid type at "${path}.type": "${escapeFieldNameForDisplay(typeValue)}" (expected number|string|boolean|wref|array, optionally with ? suffix)`
+    );
+    return;
+  }
+  if ("description" in spec && typeof spec.description !== "string") {
+    errors.push(
+      `Invalid typed field object at "${path}": "description" must be a string`
+    );
+  }
+  const baseType = typeValue.endsWith("?") ? typeValue.slice(0, -1) : typeValue;
+  for (const key of Object.keys(spec)) {
+    if (key === "type" || key === "description") continue;
+    const safeKey = escapeFieldNameForDisplay(key);
+    if (baseType === "string") {
+      if (!STRING_CONSTRAINT_KEYS.has(key)) {
+        errors.push(
+          `Constraint "${safeKey}" at "${path}" is not valid for type "string"`
+        );
+      }
+    } else if (baseType === "number") {
+      if (!NUMBER_CONSTRAINT_KEYS.has(key)) {
+        errors.push(
+          `Constraint "${safeKey}" at "${path}" is not valid for type "number"`
+        );
+      }
+    } else if (baseType === "wref") {
+      if (!WREF_CONSTRAINT_KEYS.has(key)) {
+        errors.push(
+          `Constraint "${safeKey}" at "${path}" is not valid for type "wref"`
+        );
+      }
+    } else if (baseType === "array") {
+      if (!ARRAY_CONSTRAINT_KEYS.has(key)) {
+        errors.push(
+          `Constraint "${safeKey}" at "${path}" is not valid for type "array"`
+        );
+      }
+    } else {
+      errors.push(
+        `Constraint "${safeKey}" at "${path}" is not valid for type "${baseType}"`
+      );
+    }
+  }
+  if ("minLength" in spec && (typeof spec.minLength !== "number" || !Number.isFinite(spec.minLength) || spec.minLength < 0 || !Number.isInteger(spec.minLength))) {
+    errors.push(
+      `"minLength" at "${path}" must be a non-negative finite integer`
+    );
+  }
+  if ("maxLength" in spec && (typeof spec.maxLength !== "number" || !Number.isFinite(spec.maxLength) || spec.maxLength < 0 || !Number.isInteger(spec.maxLength))) {
+    errors.push(
+      `"maxLength" at "${path}" must be a non-negative finite integer`
+    );
+  }
+  if ("minLength" in spec && "maxLength" in spec && typeof spec.minLength === "number" && typeof spec.maxLength === "number" && spec.minLength > spec.maxLength) {
+    errors.push(`"minLength" at "${path}" cannot exceed "maxLength"`);
+  }
+  if (baseType === "string" && typeof spec.minLength === "number" && Number.isFinite(spec.minLength) && Number.isInteger(spec.minLength) && spec.minLength > MAX_CONTENT_FIELD_BYTES) {
+    errors.push(
+      `"minLength" at "${path}" cannot exceed ${MAX_CONTENT_FIELD_BYTES}`
+    );
+  }
+  if (baseType === "string" && typeof spec.maxLength === "number" && Number.isFinite(spec.maxLength) && Number.isInteger(spec.maxLength) && spec.maxLength > MAX_CONTENT_FIELD_BYTES) {
+    errors.push(
+      `"maxLength" at "${path}" cannot exceed ${MAX_CONTENT_FIELD_BYTES}`
+    );
+  }
+  if ("pattern" in spec && typeof spec.pattern !== "string") {
+    errors.push(`"pattern" at "${path}" must be a string`);
+  }
+  if ("pattern" in spec && typeof spec.pattern === "string") {
+    if (nativeRegexSyntaxError(spec.pattern)) {
+      errors.push(`"pattern" at "${path}" is not a valid regular expression`);
+    } else {
+      const unsupportedReason = unsupportedPortablePatternReason(spec.pattern);
+      if (unsupportedReason) {
+        errors.push(`"pattern" at "${path}" ${unsupportedReason}`);
+      }
+    }
+  }
+  if ("enum" in spec) {
+    if (!Array.isArray(spec.enum) || spec.enum.length === 0 || !spec.enum.every((v) => typeof v === "string")) {
+      errors.push(`"enum" at "${path}" must be a non-empty array of strings`);
+    } else if (baseType === "string") {
+      for (const value of spec.enum) {
+        const byteLength = utf8ByteLength(value);
+        if (byteLength > MAX_CONTENT_FIELD_BYTES) {
+          errors.push(
+            `"enum" value at "${path}" is ${byteLength} bytes; string enum values cannot exceed ${MAX_CONTENT_FIELD_BYTES} bytes`
+          );
+          break;
+        }
+      }
+    }
+  }
+  if ("minimum" in spec && (typeof spec.minimum !== "number" || !Number.isFinite(spec.minimum))) {
+    errors.push(`"minimum" at "${path}" must be a finite number`);
+  }
+  if ("maximum" in spec && (typeof spec.maximum !== "number" || !Number.isFinite(spec.maximum))) {
+    errors.push(`"maximum" at "${path}" must be a finite number`);
+  }
+  if ("minimum" in spec && "maximum" in spec && typeof spec.minimum === "number" && typeof spec.maximum === "number" && spec.minimum > spec.maximum) {
+    errors.push(`"minimum" at "${path}" cannot exceed "maximum"`);
+  }
+  if ("integer" in spec && typeof spec.integer !== "boolean") {
+    errors.push(`"integer" at "${path}" must be a boolean`);
+  }
+  if ("shape" in spec) {
+    if (typeof spec.shape !== "string") {
+      errors.push(`"shape" at "${path}" must be a string (shape name)`);
+    } else if (spec.shape === "") {
+      errors.push(`"shape" at "${path}" must not be empty`);
+    }
+  }
+  if ("minItems" in spec && (typeof spec.minItems !== "number" || !Number.isFinite(spec.minItems) || spec.minItems < 0 || !Number.isInteger(spec.minItems))) {
+    errors.push(`"minItems" at "${path}" must be a non-negative finite integer`);
+  }
+  if ("maxItems" in spec && (typeof spec.maxItems !== "number" || !Number.isFinite(spec.maxItems) || spec.maxItems < 0 || !Number.isInteger(spec.maxItems))) {
+    errors.push(`"maxItems" at "${path}" must be a non-negative finite integer`);
+  }
+  if ("minItems" in spec && "maxItems" in spec && typeof spec.minItems === "number" && typeof spec.maxItems === "number" && spec.minItems > spec.maxItems) {
+    errors.push(`"minItems" at "${path}" cannot exceed "maxItems"`);
+  }
+  if (baseType === "array") {
+    if (!("items" in spec)) {
+      errors.push(
+        `Typed array at "${path}" must have an "items" key specifying the element type`
+      );
+    } else {
+      validateTypeSpec(
+        `${path}.items`,
+        `${identityPath}.items`,
+        spec.items,
+        errors,
+        context
+      );
     }
-    return;
   }
-  errors.push(
-    `Invalid type at "${path}": expected string, array, or object, got ${typeof spec}`
-  );
+}
+
+// ../rules/src/shape-validation-definition.ts
+function validationContext(options = {}) {
+  return {
+    allowUnsafeFieldNamePaths: new Set(options.allowUnsafeFieldNamePaths ?? [])
+  };
+}
+function isAllowedLegacyUnsafeFieldPath2(context, path) {
+  return context.allowUnsafeFieldNamePaths.has(path);
 }
 var ALLOWED_SHAPE_KEYS = /* @__PURE__ */ new Set(["fields", "description"]);
 function collectIndexableShapeFieldPaths(fields, prefix = "") {
@@ -7502,7 +7816,7 @@ function validateFieldsRecord(fields, prefix, errors, context, identityPrefix =
     const verdict = isUnsafeFieldName(bareKey);
     const fieldPath = joinFieldPath(prefix, key);
     const fieldIdentityPath = joinFieldIdentityPath(identityPrefix, key);
-    if (verdict.unsafe && !isAllowedLegacyUnsafeFieldPath(context, fieldIdentityPath)) {
+    if (verdict.unsafe && !isAllowedLegacyUnsafeFieldPath2(context, fieldIdentityPath)) {
       errors.push(`Invalid field name at "${fieldPath}": ${verdict.reason}`);
       continue;
     }
@@ -7530,8 +7844,9 @@ function validateFieldsRecord(fields, prefix, errors, context, identityPrefix =
 }
 function collectUnsafeFieldNamePathsInTypeSpec(path, spec, paths) {
   if (Array.isArray(spec)) {
-    if (spec.length === 1)
+    if (spec.length === 1) {
       collectUnsafeFieldNamePathsInTypeSpec(`${path}[]`, spec[0], paths);
+    }
     return;
   }
   if (isTypeSpecObject(spec)) {
@@ -7576,360 +7891,72 @@ function collectUnsafeShapeFieldNamePaths(data) {
     paths
   );
   return paths;
-}
-function validateShapeDefinition(data, options = {}) {
-  if (typeof data !== "object" || data === null || Array.isArray(data)) {
-    return { valid: false, errors: ["Shape definition must be a plain object"] };
-  }
-  const obj = data;
-  const errors = [];
-  for (const key of Object.keys(obj)) {
-    if (!ALLOWED_SHAPE_KEYS.has(key)) {
-      errors.push(
-        `Unsupported shape definition key "${escapeFieldNameForDisplay(key)}"`
-      );
-    }
-  }
-  if (!("fields" in obj)) {
-    return {
-      valid: false,
-      errors: ['Shape definition must have a "fields" property']
-    };
-  }
-  const fields = obj.fields;
-  if (typeof fields !== "object" || fields === null || Array.isArray(fields)) {
-    return {
-      valid: false,
-      errors: ['"fields" must be a plain object mapping field names to types']
-    };
-  }
-  const context = validationContext(options);
-  validateFieldsRecord(
-    fields,
-    "fields",
-    errors,
-    context
-  );
-  const indexableFieldPaths = collectIndexableShapeFieldPaths(
-    fields
-  );
-  const indexableFieldCount = indexableFieldPaths.length;
-  const seenIndexableFieldPaths = /* @__PURE__ */ new Set();
-  const duplicateIndexableFieldPaths = /* @__PURE__ */ new Set();
-  for (const fieldPath of indexableFieldPaths) {
-    const foldedPath = foldFieldPath(fieldPath);
-    if (seenIndexableFieldPaths.has(foldedPath)) {
-      duplicateIndexableFieldPaths.add(foldedPath);
-      continue;
-    }
-    seenIndexableFieldPaths.add(foldedPath);
-  }
-  for (const fieldPath of duplicateIndexableFieldPaths) {
-    errors.push(
-      `Shape declares ambiguous indexable field path "${escapeFieldNameForDisplay(fieldPath)}"; dotted field names, optional-key suffixes, and case-insensitive folded paths must not collide with another indexable path`
-    );
-  }
-  if (indexableFieldCount > MAX_INDEXABLE_SCALAR_FIELDS_PER_SHAPE) {
-    errors.push(
-      `Shape declares ${indexableFieldCount} indexable scalar fields; maximum is ${MAX_INDEXABLE_SCALAR_FIELDS_PER_SHAPE}`
-    );
-  }
-  if ("description" in obj && typeof obj.description !== "string") {
-    errors.push('"description" must be a string');
-  }
-  validatePersistedStringFieldLimits(obj, void 0, errors);
-  if (errors.length > 0) {
-    return { valid: false, errors };
-  }
-  return { valid: true };
-}
-function validateAgainstShape(data, shapeFields) {
-  return compileShapeValidator(shapeFields)(data);
-}
-function declaredFieldNames(shapeFields) {
-  const declared = /* @__PURE__ */ new Set();
-  for (const key of Object.keys(shapeFields)) {
-    declared.add(key.endsWith("?") ? key.slice(0, -1) : key);
-  }
-  return declared;
-}
-function buildUndeclaredFieldsWarningFromDeclaredSet(data, declared) {
-  const undeclaredFields = [];
-  let totalUndeclared = 0;
-  for (const key of Object.keys(data)) {
-    if (declared.has(key)) continue;
-    totalUndeclared++;
-    if (undeclaredFields.length < MAX_UNDECLARED_FIELDS_REPORTED) {
-      undeclaredFields.push(key);
-    }
-  }
-  if (totalUndeclared === 0) return void 0;
-  if (totalUndeclared > MAX_UNDECLARED_FIELDS_REPORTED) {
-    return {
-      undeclaredFields,
-      undeclaredFieldsTruncated: true,
-      totalUndeclared
-    };
-  }
-  return { undeclaredFields };
-}
-var MAX_UNDECLARED_FIELDS_REPORTED = 500;
-function compileShapeValidator(shapeFields) {
-  const compiledFields = compileObjectFields(shapeFields);
-  const declared = declaredFieldNames(shapeFields);
-  return (data) => {
-    const errors = [];
-    if (typeof data !== "object" || data === null || Array.isArray(data)) {
-      return { valid: false, errors: ["Data must be a plain object"] };
-    }
-    for (const field of compiledFields) {
-      const value = data[field.fieldName];
-      if (value === void 0 || value === null) {
-        if (!field.isOptional) {
-          errors.push(`Missing required field: "${field.displayName}"`);
-        }
-        continue;
-      }
-      field.validate(field.displayName, value, errors);
-    }
-    validatePersistedStringFieldLimits(data, shapeFields, errors);
-    const warnings = buildUndeclaredFieldsWarningFromDeclaredSet(data, declared);
-    if (errors.length > 0) {
-      return warnings ? { valid: false, errors, warnings } : { valid: false, errors };
-    }
-    return warnings ? { valid: true, warnings } : { valid: true };
-  };
-}
-function validatePersistedStringFieldLimits(value, typeDef, errors, path) {
-  const normalized = normalizeOptionalTypeSpec(typeDef).spec;
-  if (typeof value === "string") {
-    if (isDeclaredStringType(normalized) || isDeclaredWrefType(normalized))
-      return;
-    if (normalized !== void 0) return;
-    assertContentFieldWithinLimit(path ?? "<value>", value, errors);
-    return;
-  }
-  if (Array.isArray(value)) {
-    const elementType = arrayElementType(normalized);
-    if (normalized !== void 0 && elementType === void 0) return;
-    for (let i = 0; i < value.length; i++) {
-      validatePersistedStringFieldLimits(
-        value[i],
-        elementType,
-        errors,
-        `${path ?? "<value>"}[${i}]`
-      );
-    }
-    return;
-  }
-  if (!isPlainObject(value)) return;
-  const fields = nestedObjectFields(normalized);
-  if (normalized !== void 0 && fields === void 0) return;
-  for (const [key, nestedValue] of Object.entries(value)) {
-    validatePersistedStringFieldLimits(
-      nestedValue,
-      fields?.get(key),
-      errors,
-      path ? joinFieldPath(path, key) : escapeFieldNameForDisplay(key)
-    );
-  }
-}
-function isDeclaredStringType(typeDef) {
-  if (typeDef === "string") return true;
-  return isTypeSpecObject(typeDef) && typeDef.type === "string";
-}
-function isDeclaredWrefType(typeDef) {
-  if (typeDef === "wref") return true;
-  return isTypeSpecObject(typeDef) && typeDef.type === "wref";
-}
-function arrayElementType(typeDef) {
-  if (Array.isArray(typeDef)) return typeDef[0];
-  if (isTypeSpecObject(typeDef) && typeDef.type === "array")
-    return typeDef.items;
-  return void 0;
-}
-function nestedObjectFields(typeDef) {
-  if (!isPlainObject(typeDef) || isTypeSpecObject(typeDef)) return void 0;
-  const fields = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(typeDef)) {
-    fields.set(key.endsWith("?") ? key.slice(0, -1) : key, value);
-  }
-  return fields;
-}
-function compileObjectFields(shapeFields) {
-  return Object.entries(shapeFields).map(([fieldSpec, rawTypeDef]) => {
-    const isOptionalByKey = fieldSpec.endsWith("?");
-    const fieldName = isOptionalByKey ? fieldSpec.slice(0, -1) : fieldSpec;
-    const normalized = normalizeOptionalTypeSpec(rawTypeDef);
-    return {
-      fieldName,
-      displayName: escapeFieldNameForDisplay(fieldName),
-      isOptional: isOptionalByKey || normalized.optionalByType,
-      validate: compileTypeValidator(normalized.spec)
-    };
-  });
-}
-function compileTypeValidator(typeDef) {
-  if (typeof typeDef === "string") {
-    return (path, value, errors) => validatePrimitiveField(path, value, typeDef, errors);
-  }
-  if (Array.isArray(typeDef)) {
-    const elementValidator = typeDef.length > 0 ? compileTypeValidator(normalizeOptionalTypeSpec(typeDef[0]).spec) : void 0;
-    return (path, value, errors) => {
-      if (!Array.isArray(value)) {
-        errors.push(`Field "${path}" expected array, got ${typeof value}`);
-      } else if (elementValidator) {
-        for (let i = 0; i < value.length; i++) {
-          elementValidator(`${path}[${i}]`, value[i], errors);
-        }
-      }
-    };
+}
+function validateShapeDefinition(data, options = {}) {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    return { valid: false, errors: ["Shape definition must be a plain object"] };
   }
-  if (isTypeSpecObject(typeDef)) {
-    const baseType = typeDef.type.endsWith("?") ? typeDef.type.slice(0, -1) : typeDef.type;
-    if (baseType === "array") {
-      const elementValidator = "items" in typeDef && typeDef.items != null ? compileTypeValidator(normalizeOptionalTypeSpec(typeDef.items).spec) : void 0;
-      return (path, value, errors) => {
-        if (!Array.isArray(value)) {
-          errors.push(`Field "${path}" expected array, got ${typeof value}`);
-          return;
-        }
-        if (typeof typeDef.minItems === "number" && value.length < typeDef.minItems) {
-          errors.push(
-            `Field "${path}" has ${value.length} items, minimum is ${typeDef.minItems}`
-          );
-        }
-        if (typeof typeDef.maxItems === "number" && value.length > typeDef.maxItems) {
-          errors.push(
-            `Field "${path}" has ${value.length} items, maximum is ${typeDef.maxItems}`
-          );
-        }
-        if (elementValidator) {
-          for (let i = 0; i < value.length; i++) {
-            elementValidator(`${path}[${i}]`, value[i], errors);
-          }
-        }
-      };
+  const obj = data;
+  const errors = [];
+  for (const key of Object.keys(obj)) {
+    if (!ALLOWED_SHAPE_KEYS.has(key)) {
+      errors.push(
+        `Unsupported shape definition key "${escapeFieldNameForDisplay(key)}"`
+      );
     }
-    const validateConstraintsCompiled = compileConstraintsValidator(typeDef);
-    return (path, value, errors) => {
-      validatePrimitiveField(path, value, typeDef.type, errors);
-      validateConstraintsCompiled(path, value, errors);
+  }
+  if (!("fields" in obj)) {
+    return {
+      valid: false,
+      errors: ['Shape definition must have a "fields" property']
     };
   }
-  if (isPlainObject(typeDef)) {
-    const compiledFields = compileObjectFields(typeDef);
-    return (path, value, errors) => {
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        errors.push(`Field "${path}" expected object, got ${typeof value}`);
-        return;
-      }
-      const objValue = value;
-      for (const field of compiledFields) {
-        const subValue = objValue[field.fieldName];
-        const subPath = joinFieldPath(path, field.fieldName);
-        if (subValue === void 0 || subValue === null) {
-          if (!field.isOptional) {
-            errors.push(`Missing required field: "${subPath}"`);
-          }
-          continue;
-        }
-        field.validate(subPath, subValue, errors);
-      }
+  const fields = obj.fields;
+  if (typeof fields !== "object" || fields === null || Array.isArray(fields)) {
+    return {
+      valid: false,
+      errors: ['"fields" must be a plain object mapping field names to types']
     };
   }
-  return () => {
-  };
-}
-function compileConstraintsValidator(spec) {
-  const pattern = typeof spec.pattern === "string" ? spec.pattern : void 0;
-  const patternConstraint = pattern === void 0 ? void 0 : compilePatternConstraint(pattern);
-  return (path, value, errors) => {
-    if (typeof value === "string") {
-      if (typeof spec.minLength === "number" && value.length < spec.minLength) {
-        errors.push(
-          `Field "${path}" length ${value.length} is below minimum ${spec.minLength}`
-        );
-      }
-      if (typeof spec.maxLength === "number" && value.length > spec.maxLength) {
-        errors.push(
-          `Field "${path}" length ${value.length} exceeds maximum ${spec.maxLength}`
-        );
-      }
-      if (pattern !== void 0) {
-        const safePattern = escapeFieldNameForDisplay(pattern);
-        if (patternConstraint?.kind === "unsupported") {
-          errors.push(
-            `Field "${path}" has unsupported pattern "${safePattern}"`
-          );
-        } else if (patternConstraint?.kind === "invalid") {
-          errors.push(
-            `Field "${path}" has invalid pattern "${safePattern}" \u2014 skipping regex check`
-          );
-        } else if (patternConstraint?.kind === "compiled" && !patternConstraint.regex.test(value)) {
-          errors.push(`Field "${path}" does not match pattern "${safePattern}"`);
-        }
-      }
-      if (Array.isArray(spec.enum) && !spec.enum.includes(value)) {
-        errors.push(
-          `Field "${path}" value "${escapeFieldNameForDisplay(String(value))}" is not in allowed values: ${spec.enum.map((entry) => escapeFieldNameForDisplay(String(entry))).join(", ")}`
-        );
-      }
-    }
-    if (typeof value === "number") {
-      if (typeof spec.minimum === "number" && value < spec.minimum) {
-        errors.push(
-          `Field "${path}" value ${value} is below minimum ${spec.minimum}`
-        );
-      }
-      if (typeof spec.maximum === "number" && value > spec.maximum) {
-        errors.push(
-          `Field "${path}" value ${value} exceeds maximum ${spec.maximum}`
-        );
-      }
-      if (spec.integer === true && !Number.isInteger(value)) {
-        errors.push(`Field "${path}" must be an integer, got ${value}`);
-      }
+  const context = validationContext(options);
+  validateFieldsRecord(
+    fields,
+    "fields",
+    errors,
+    context
+  );
+  const indexableFieldPaths = collectIndexableShapeFieldPaths(
+    fields
+  );
+  const indexableFieldCount = indexableFieldPaths.length;
+  const seenIndexableFieldPaths = /* @__PURE__ */ new Set();
+  const duplicateIndexableFieldPaths = /* @__PURE__ */ new Set();
+  for (const fieldPath of indexableFieldPaths) {
+    const foldedPath = foldFieldPath(fieldPath);
+    if (seenIndexableFieldPaths.has(foldedPath)) {
+      duplicateIndexableFieldPaths.add(foldedPath);
+      continue;
     }
-  };
-}
-function compilePatternConstraint(pattern) {
-  if (nativeRegexSyntaxError(pattern)) {
-    return { kind: "invalid" };
+    seenIndexableFieldPaths.add(foldedPath);
   }
-  const regex = compilePortablePattern(pattern);
-  return regex ? { kind: "compiled", regex } : { kind: "unsupported" };
-}
-function validatePrimitiveField(path, value, typeDef, errors) {
-  switch (typeDef) {
-    case "number":
-      if (typeof value !== "number") {
-        errors.push(`Field "${path}" expected number, got ${typeof value}`);
-      }
-      break;
-    case "string":
-      if (typeof value !== "string") {
-        errors.push(`Field "${path}" expected string, got ${typeof value}`);
-      } else {
-        assertContentFieldWithinLimit(path, value, errors);
-      }
-      break;
-    case "wref":
-      if (typeof value !== "string") {
-        errors.push(`Field "${path}" expected string, got ${typeof value}`);
-      }
-      break;
-    case "boolean":
-      if (typeof value !== "boolean") {
-        errors.push(`Field "${path}" expected boolean, got ${typeof value}`);
-      }
-      break;
-    case "array":
-      if (!Array.isArray(value)) {
-        errors.push(`Field "${path}" expected array, got ${typeof value}`);
-      }
-      break;
+  for (const fieldPath of duplicateIndexableFieldPaths) {
+    errors.push(
+      `Shape declares ambiguous indexable field path "${escapeFieldNameForDisplay(fieldPath)}"; dotted field names, optional-key suffixes, and case-insensitive folded paths must not collide with another indexable path`
+    );
+  }
+  if (indexableFieldCount > MAX_INDEXABLE_SCALAR_FIELDS_PER_SHAPE) {
+    errors.push(
+      `Shape declares ${indexableFieldCount} indexable scalar fields; maximum is ${MAX_INDEXABLE_SCALAR_FIELDS_PER_SHAPE}`
+    );
+  }
+  if ("description" in obj && typeof obj.description !== "string") {
+    errors.push('"description" must be a string');
+  }
+  validatePersistedStringFieldLimits(obj, void 0, errors);
+  if (errors.length > 0) {
+    return { valid: false, errors };
   }
+  return { valid: true };
 }
 
 // ../rules/src/system-components/system.ts
@@ -8011,7 +8038,7 @@ var collectionTypes2 = /* @__PURE__ */ new Set([
   "list"
 ]);
 function normalizeBackendCollectionAdd(operation, source) {
-  const diagnostics = preflightOpDiagnostics(
+  const diagnostics = preflightOpDiagnostics2(
     {
       operation: "add",
       kind: "collection",
@@ -8166,21 +8193,72 @@ function toBackendStreamOperation(operation) {
       ...skipExisting === true ? { skipExisting } : {}
     };
   }
-  if (operation.data === void 0) {
-    throw new Error(`${kind} add operation requires 'data'`);
-  }
-  return {
-    operation: "add",
-    kind,
-    name: operation.name,
-    data: operation.data,
-    ...skipExisting === true ? { skipExisting } : {}
-  };
-}
+  if (operation.data === void 0) {
+    throw new Error(`${kind} add operation requires 'data'`);
+  }
+  return {
+    operation: "add",
+    kind,
+    name: operation.name,
+    data: operation.data,
+    ...skipExisting === true ? { skipExisting } : {}
+  };
+}
+
+// src/stream-submit-types.ts
+var DEFAULT_STREAM_CHUNK_SIZE = DEFAULT_STREAM_APPEND_CHUNK_SIZE;
+var MAX_STREAM_APPEND_OPERATION_COUNT2 = MAX_STREAM_APPEND_OPERATION_COUNT;
+var PartialStreamSubmissionError = class extends Error {
+  /**
+   * Stable error code. Always `'PARTIAL_STREAM_SUBMISSION'`.
+   */
+  code = "PARTIAL_STREAM_SUBMISSION";
+  /**
+   * Operations the SDK confirmed completed before the ambiguous or failing
+   * append. The remaining operations may or may not have landed; inspect
+   * repository state before retrying manually.
+   */
+  completedOperations;
+  /**
+   * Underlying error that triggered the partial submission, preserved for
+   * diagnostics. Inspect via `isWarmHubError(err.cause)` / `err.cause.kind`.
+   */
+  cause;
+  constructor(input) {
+    super(
+      "Stream submission failed. A timed-out append may already have landed, so inspect repository state before sending any further operations."
+    );
+    this.name = "WarmHubError";
+    this.cause = input.cause;
+    this.completedOperations = input.completedOperations;
+  }
+};
+var AllStreamOperationsFailedError = class extends Error {
+  code = "STREAM_ALL_OPERATIONS_FAILED";
+  result;
+  operations;
+  statusCounts;
+  cause;
+  constructor(result) {
+    const primaryFailure = result.operations.find(
+      (operation) => operation.error !== void 0
+    )?.error;
+    super(
+      primaryFailure ? `All ${result.operationCount} stream operations failed: ${primaryFailure.message}` : `All ${result.operationCount} stream operations failed.`
+    );
+    this.name = "WarmHubError";
+    this.cause = primaryFailure;
+    this.result = result;
+    this.operations = result.operations;
+    this.statusCounts = result.statusCounts ?? {
+      applied: 0,
+      noop: 0,
+      error: result.operationCount
+    };
+  }
+};
 
-// src/stream-submit.ts
-var DEFAULT_STREAM_CHUNK_SIZE = DEFAULT_STREAM_APPEND_CHUNK_SIZE;
-var MAX_STREAM_APPEND_OPERATION_COUNT2 = MAX_STREAM_APPEND_OPERATION_COUNT;
+// src/stream-submit-utils.ts
 function streamAppendResultStatus(result) {
   if (result.status === "failed") {
     return "error";
@@ -8232,6 +8310,85 @@ function resolveRetryPolicy(retry) {
     )
   };
 }
+var DEFINITE_CLIENT_REJECT_CODES = /* @__PURE__ */ new Set([
+  "UNAUTHENTICATED",
+  "FORBIDDEN",
+  "VALIDATION_ERROR",
+  "SHAPE_MISMATCH",
+  "RESERVED_NAME",
+  "ILLEGAL_OP_SEQUENCE",
+  "NOT_FOUND",
+  "KIND_MISMATCH",
+  "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.).
+  "RATE_LIMITED",
+  "UNRESOLVED_TOKEN"
+]);
+function extractErrorCode(cause) {
+  if (!cause || typeof cause !== "object") return void 0;
+  const direct = cause.code;
+  if (typeof direct === "string") return direct;
+  const data = cause.data;
+  const wh = data?.warmhub?.code;
+  if (typeof wh === "string") return wh;
+  const dc = data?.code;
+  if (typeof dc === "string") return dc;
+  return void 0;
+}
+function isDefiniteClientError(cause) {
+  const code = extractErrorCode(cause);
+  return code !== void 0 && DEFINITE_CLIENT_REJECT_CODES.has(code);
+}
+function isTransientStreamFailure(cause) {
+  if (isDefiniteClientError(cause)) return false;
+  if (isFetchNetworkTypeError(cause)) return true;
+  if (cause instanceof TypeError) return false;
+  if (cause instanceof SyntaxError) return false;
+  const inner = cause?.cause;
+  if (isFetchNetworkTypeError(inner)) return true;
+  if (inner instanceof TypeError) return false;
+  if (inner instanceof SyntaxError) return false;
+  return true;
+}
+function isFetchNetworkTypeError(cause) {
+  return cause instanceof TypeError && /fetch/i.test(cause.message);
+}
+function computeBackoffDelayMs(attempt, policy) {
+  const exponential = policy.baseDelayMs * 2 ** Math.max(0, attempt - 1);
+  const jitter = Math.random() * policy.baseDelayMs;
+  return Math.min(policy.maxDelayMs, exponential + jitter);
+}
+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";
   status = 400;
@@ -8240,55 +8397,6 @@ var StreamValidationError = class extends Error {
     this.name = "WarmHubError";
   }
 };
-var PartialStreamSubmissionError = class extends Error {
-  /**
-   * Stable error code. Always `'PARTIAL_STREAM_SUBMISSION'`.
-   */
-  code = "PARTIAL_STREAM_SUBMISSION";
-  /**
-   * Operations the SDK confirmed completed before the ambiguous or failing
-   * append. The remaining operations may or may not have landed; inspect
-   * repository state before retrying manually.
-   */
-  completedOperations;
-  /**
-   * Underlying error that triggered the partial submission, preserved for
-   * diagnostics. Inspect via `isWarmHubError(err.cause)` / `err.cause.kind`.
-   */
-  cause;
-  constructor(input) {
-    super(
-      "Stream submission failed. A timed-out append may already have landed, so inspect repository state before sending any further operations."
-    );
-    this.name = "WarmHubError";
-    this.cause = input.cause;
-    this.completedOperations = input.completedOperations;
-  }
-};
-var AllStreamOperationsFailedError = class extends Error {
-  code = "STREAM_ALL_OPERATIONS_FAILED";
-  result;
-  operations;
-  statusCounts;
-  cause;
-  constructor(result) {
-    const primaryFailure = result.operations.find(
-      (operation) => operation.error !== void 0
-    )?.error;
-    super(
-      primaryFailure ? `All ${result.operationCount} stream operations failed: ${primaryFailure.message}` : `All ${result.operationCount} stream operations failed.`
-    );
-    this.name = "WarmHubError";
-    this.cause = primaryFailure;
-    this.result = result;
-    this.operations = result.operations;
-    this.statusCounts = result.statusCounts ?? {
-      applied: 0,
-      noop: 0,
-      error: result.operationCount
-    };
-  }
-};
 async function submitOperationsViaStream(client, args) {
   if (args.operations.length === 0) {
     throw new StreamValidationError(
@@ -8362,138 +8470,61 @@ async function submitOperationsViaStream(client, args) {
           toSubmittedStreamResult(
             {
               operationCount: chunkResults.length
-            },
-            args.committer,
-            createdByEmail,
-            args.message,
-            chunkResults,
-            operations
-          )
-        );
-        throw new PartialStreamSubmissionError({
-          cause,
-          completedOperations
-        });
-      }
-    }
-  }
-  const result = toSubmittedStreamResult(
-    {
-      operationCount: chunkResults.length
-    },
-    args.committer,
-    createdByEmail,
-    args.message,
-    chunkResults,
-    operations
-  );
-  if (isAllSubmittedOperationsFailed(result, operations.length)) {
-    const failure = new AllStreamOperationsFailedError(result);
-    if (sawAmbiguousAttempt) {
-      throw new PartialStreamSubmissionError({
-        cause: failure,
-        completedOperations: completedOperationsFrom(result)
-      });
-    }
-    throw failure;
-  }
-  return result;
-}
-function isAllSubmittedOperationsFailed(result, submittedOperationCount) {
-  if (submittedOperationCount <= 0) {
-    return false;
-  }
-  const inputRowsFailed = /* @__PURE__ */ new Map();
-  for (const operation of result.operations) {
-    if (operation.opIndex === void 0 || operation.opIndex < 0 || operation.opIndex >= submittedOperationCount) {
-      continue;
-    }
-    inputRowsFailed.set(
-      operation.opIndex,
-      (inputRowsFailed.get(operation.opIndex) ?? true) && operation.status === "error"
-    );
-  }
-  return inputRowsFailed.size === submittedOperationCount && [...inputRowsFailed.values()].every(Boolean);
-}
-function completedOperationsFrom(result) {
-  return result.operations.filter((operation) => operation.status !== "error");
-}
-var DEFINITE_CLIENT_REJECT_CODES = /* @__PURE__ */ new Set([
-  "UNAUTHENTICATED",
-  "FORBIDDEN",
-  "VALIDATION_ERROR",
-  "SHAPE_MISMATCH",
-  "RESERVED_NAME",
-  "ILLEGAL_OP_SEQUENCE",
-  "NOT_FOUND",
-  "KIND_MISMATCH",
-  "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.).
-  "RATE_LIMITED",
-  "UNRESOLVED_TOKEN"
-]);
-function extractErrorCode(cause) {
-  if (!cause || typeof cause !== "object") return void 0;
-  const direct = cause.code;
-  if (typeof direct === "string") return direct;
-  const data = cause.data;
-  const wh = data?.warmhub?.code;
-  if (typeof wh === "string") return wh;
-  const dc = data?.code;
-  if (typeof dc === "string") return dc;
-  return void 0;
-}
-function isDefiniteClientError(cause) {
-  const code = extractErrorCode(cause);
-  return code !== void 0 && DEFINITE_CLIENT_REJECT_CODES.has(code);
-}
-function isTransientStreamFailure(cause) {
-  if (isDefiniteClientError(cause)) return false;
-  if (isFetchNetworkTypeError(cause)) return true;
-  if (cause instanceof TypeError) return false;
-  if (cause instanceof SyntaxError) return false;
-  const inner = cause?.cause;
-  if (isFetchNetworkTypeError(inner)) return true;
-  if (inner instanceof TypeError) return false;
-  if (inner instanceof SyntaxError) return false;
-  return true;
-}
-function isFetchNetworkTypeError(cause) {
-  return cause instanceof TypeError && /fetch/i.test(cause.message);
-}
-function computeBackoffDelayMs(attempt, policy) {
-  const exponential = policy.baseDelayMs * 2 ** Math.max(0, attempt - 1);
-  const jitter = Math.random() * policy.baseDelayMs;
-  return Math.min(policy.maxDelayMs, exponential + jitter);
-}
-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);
+            },
+            args.committer,
+            createdByEmail,
+            args.message,
+            chunkResults,
+            operations
+          )
+        );
+        throw new PartialStreamSubmissionError({
+          cause,
+          completedOperations
+        });
+      }
+    }
+  }
+  const result = toSubmittedStreamResult(
+    {
+      operationCount: chunkResults.length
+    },
+    args.committer,
+    createdByEmail,
+    args.message,
+    chunkResults,
+    operations
+  );
+  if (isAllSubmittedOperationsFailed(result, operations.length)) {
+    const failure = new AllStreamOperationsFailedError(result);
+    if (sawAmbiguousAttempt) {
+      throw new PartialStreamSubmissionError({
+        cause: failure,
+        completedOperations: completedOperationsFrom(result)
+      });
+    }
+    throw failure;
+  }
+  return result;
 }
-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));
+function isAllSubmittedOperationsFailed(result, submittedOperationCount) {
+  if (submittedOperationCount <= 0) {
+    return false;
+  }
+  const inputRowsFailed = /* @__PURE__ */ new Map();
+  for (const operation of result.operations) {
+    if (operation.opIndex === void 0 || operation.opIndex < 0 || operation.opIndex >= submittedOperationCount) {
+      continue;
     }
-    return Object.values(value).some(
-      (entry) => structuralValueHasTokenRef(entry, seen)
+    inputRowsFailed.set(
+      operation.opIndex,
+      (inputRowsFailed.get(operation.opIndex) ?? true) && operation.status === "error"
     );
   }
-  return false;
+  return inputRowsFailed.size === submittedOperationCount && [...inputRowsFailed.values()].every(Boolean);
 }
-function opUsesTokens(op) {
-  return stringHasTokenRef(op.name) || stringHasTokenRef(op.wref) || structuralValueHasTokenRef(op.about) || stringHasTokenRef(op.aboutWref) || structuralValueHasTokenRef(op.members) || structuralValueHasTokenRef(op.data);
+function completedOperationsFrom(result) {
+  return result.operations.filter((operation) => operation.status !== "error");
 }
 function createStreamId() {
   return globalThis.crypto?.randomUUID?.() ?? `stream-${Date.now()}-${Math.random()}`;
@@ -8697,39 +8728,234 @@ async function verifyCliCall(request, secrets, opts) {
       );
     }
   }
-  return { method: cliMethod, installRepo, args };
-}
-function isNonEmpty(value) {
-  return typeof value === "string" && value.length > 0;
-}
-function isArgsRecord(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
+  return { method: cliMethod, installRepo, args };
+}
+function isNonEmpty(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isArgsRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  for (const v of Object.values(value)) {
+    if (v === void 0) continue;
+    if (typeof v === "string") continue;
+    if (typeof v === "number") continue;
+    if (typeof v === "boolean") continue;
+    return false;
+  }
+  return true;
+}
+async function constantTimeEqual(a, b) {
+  const [aDigest, bDigest] = await Promise.all([sha256(a), sha256(b)]);
+  let diff = 0;
+  for (let i = 0; i < aDigest.length; i++) {
+    diff |= aDigest[i] ^ bDigest[i];
+  }
+  return diff === 0;
+}
+async function sha256(value) {
+  return new Uint8Array(
+    await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value))
+  );
+}
+
+// src/operation-builder-helpers.ts
+function inferShapeFromLocalPath(name) {
+  if (!name.includes("/")) return void 0;
+  return name.split("/")[0];
+}
+function inferShapeForAdd(op) {
+  if ("shapeWref" in op && typeof op.shapeWref === "string") {
+    return op.shapeWref;
+  }
+  if (op.name) {
+    return inferShapeFromLocalPath(op.name);
+  }
+  return void 0;
+}
+function asNonEmptyString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeAddKind(op) {
+  return inferOperationKind({
+    kind: op.kind,
+    name: op.name,
+    about: getAddAbout(op),
+    type: getCollectionType(op),
+    members: getCollectionMembers(op)
+  });
+}
+function getAddAbout(op) {
+  if ("about" in op && op.about !== void 0) return op.about;
+  if ("aboutWref" in op) return op.aboutWref;
+  return void 0;
+}
+function getAddData(op) {
+  return "data" in op ? op.data : void 0;
+}
+function getCollectionType(op) {
+  return "type" in op ? op.type : void 0;
+}
+function getCollectionMembers(op) {
+  return "members" in op ? op.members : void 0;
+}
+function normalizeReviseKind(op, name) {
+  return inferOperationKind({ kind: op.kind, name });
+}
+function toBackendOp(op) {
+  if (op.operation === "retract") {
+    return {
+      operation: "retract",
+      name: op.name,
+      ...op.kind ? { kind: op.kind } : {},
+      ...op.reason ? { reason: op.reason } : {},
+      ...op.leaseId ? { leaseId: op.leaseId } : {}
+    };
+  }
+  if (op.operation === "add") {
+    const kind2 = normalizeAddKind(op);
+    if (kind2 === "collection") {
+      return normalizeBackendCollectionAdd(op, "OperationBuilder");
+    }
+    const addOp = op;
+    const name2 = asNonEmptyString(addOp.name);
+    if (!name2) {
+      throw new Error("OperationBuilder: add operation missing name");
+    }
+    if (kind2 === "assertion") {
+      const about = getAddAbout(addOp);
+      if (about === void 0) {
+        throw new Error(
+          `OperationBuilder: assertion add '${name2}' missing required 'about'`
+        );
+      }
+      return {
+        operation: "add",
+        kind: kind2,
+        name: name2,
+        about,
+        data: addOp.data ?? {},
+        ...addOp.skipExisting === true ? { skipExisting: true } : {}
+      };
+    }
+    return {
+      operation: "add",
+      kind: kind2,
+      name: name2,
+      data: addOp.data ?? {},
+      ...addOp.skipExisting === true ? { skipExisting: true } : {}
+    };
+  }
+  const name = asNonEmptyString(op.name) ?? asNonEmptyString(op.wref);
+  if (!name) {
+    throw new Error(
+      "OperationBuilder: revise operation missing required target ('name' or 'wref')"
+    );
+  }
+  const kind = normalizeReviseKind(op, name);
+  if (kind === "collection") {
+    throw new Error(
+      `OperationBuilder: collection revise is no longer supported \u2014 use retract('${name}') instead`
+    );
+  }
+  return {
+    operation: "revise",
+    kind,
+    name,
+    data: op.data ?? {},
+    ...op.expectedVersion !== void 0 ? { expectedVersion: op.expectedVersion } : {},
+    ...op.leaseId ? { leaseId: op.leaseId } : {}
+  };
+}
+function toPreflightOp(op, kind) {
+  if (op.operation === "add") {
+    return {
+      operation: op.operation,
+      kind,
+      name: op.name,
+      about: getAddAbout(op),
+      type: getCollectionType(op),
+      members: getCollectionMembers(op)
+    };
+  }
+  return {
+    operation: op.operation,
+    kind,
+    name: op.name ?? op.wref
+  };
+}
+function throwAggregatedMessages(messages) {
+  if (messages.length === 0) return;
+  throw new Error(messages.join("; "));
+}
+function preflightCheckCommon(verb, kind, name, data) {
+  const errors = [];
+  const requiresLocalPath = kind === "thing" || kind === "assertion" || kind === "collection" && verb === "REVISE";
+  if (requiresLocalPath) {
+    if (!splitLocalPath(name)) {
+      errors.push(
+        `${verb} ${kind} name must be a local path (Shape/name), got: "${name}"`
+      );
+    }
+  }
+  if (kind === "shape" && (verb === "ADD" || verb === "REVISE") && data !== void 0) {
+    const preflight = shapeDefinitionPreflightError(
+      name,
+      data,
+      verb === "REVISE" ? "revise" : "add"
+    );
+    if (preflight) errors.push(preflight);
+  }
+  return errors;
+}
+function preflightCheckAdd(op, kind) {
+  const messages = [];
+  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))) {
+    messages.push(
+      `ADD assertion '${op.name}' missing required 'about' \u2014 for hierarchical thing names set kind: 'thing' explicitly`
+    );
+  }
+  if (kind !== "collection" && (getCollectionType(op) !== void 0 || getCollectionMembers(op) !== void 0)) {
+    messages.push(
+      `ADD '${op.name}' has collection fields but inferred kind '${kind}' \u2014 collection adds require both 'type' and 'members', or set kind: 'collection'`
+    );
   }
-  for (const v of Object.values(value)) {
-    if (v === void 0) continue;
-    if (typeof v === "string") continue;
-    if (typeof v === "number") continue;
-    if (typeof v === "boolean") continue;
-    return false;
+  if (kind === "collection") {
+    try {
+      normalizeBackendCollectionAdd(op, "OperationBuilder");
+    } catch (error) {
+      messages.push(error instanceof Error ? error.message : String(error));
+    }
   }
-  return true;
-}
-async function constantTimeEqual(a, b) {
-  const [aDigest, bDigest] = await Promise.all([sha256(a), sha256(b)]);
-  let diff = 0;
-  for (let i = 0; i < aDigest.length; i++) {
-    diff |= aDigest[i] ^ bDigest[i];
+  for (const diagnostic of preflightOpDiagnostics2(toPreflightOp(op, kind), 0)) {
+    messages.push(diagnostic.message);
   }
-  return diff === 0;
+  throwAggregatedMessages(messages);
 }
-async function sha256(value) {
-  return new Uint8Array(
-    await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value))
+function preflightCheckRevise(kind, name, data) {
+  const messages = [];
+  if (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)
   );
+  throwAggregatedMessages(messages);
 }
 
-// src/operation-builder.ts
+// src/operation-builder-core.ts
 var OperationBuilder = class {
   ops = [];
   pendingNames = /* @__PURE__ */ new Set();
@@ -8979,7 +9205,7 @@ var OperationBuilder = class {
         target ? normalizeReviseKind(op, target) : "thing"
       );
     });
-    const diagnostics = preflightCommitDiagnostics(preflightOps);
+    const diagnostics = preflightCommitDiagnostics2(preflightOps);
     for (const diagnostic of diagnostics) {
       errors.push({
         code: diagnostic.code,
@@ -9043,199 +9269,6 @@ var OperationBuilder = class {
     }
   }
 };
-function inferShapeFromLocalPath(name) {
-  if (!name.includes("/")) return void 0;
-  return name.split("/")[0];
-}
-function inferShapeForAdd(op) {
-  if ("shapeWref" in op && typeof op.shapeWref === "string") {
-    return op.shapeWref;
-  }
-  if (op.name) {
-    return inferShapeFromLocalPath(op.name);
-  }
-  return void 0;
-}
-function asNonEmptyString(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function normalizeAddKind(op) {
-  return inferOperationKind({
-    kind: op.kind,
-    name: op.name,
-    about: getAddAbout(op),
-    type: getCollectionType(op),
-    members: getCollectionMembers(op)
-  });
-}
-function getAddAbout(op) {
-  if ("about" in op && op.about !== void 0) return op.about;
-  if ("aboutWref" in op) return op.aboutWref;
-  return void 0;
-}
-function getAddData(op) {
-  return "data" in op ? op.data : void 0;
-}
-function getCollectionType(op) {
-  return "type" in op ? op.type : void 0;
-}
-function getCollectionMembers(op) {
-  return "members" in op ? op.members : void 0;
-}
-function normalizeReviseKind(op, name) {
-  return inferOperationKind({ kind: op.kind, name });
-}
-function toBackendOp(op) {
-  if (op.operation === "retract") {
-    return {
-      operation: "retract",
-      name: op.name,
-      ...op.kind ? { kind: op.kind } : {},
-      ...op.reason ? { reason: op.reason } : {},
-      ...op.leaseId ? { leaseId: op.leaseId } : {}
-    };
-  }
-  if (op.operation === "add") {
-    const kind2 = normalizeAddKind(op);
-    if (kind2 === "collection") {
-      return normalizeBackendCollectionAdd(op, "OperationBuilder");
-    }
-    const addOp = op;
-    const name2 = asNonEmptyString(addOp.name);
-    if (!name2) {
-      throw new Error("OperationBuilder: add operation missing name");
-    }
-    if (kind2 === "assertion") {
-      const about = getAddAbout(addOp);
-      if (about === void 0) {
-        throw new Error(
-          `OperationBuilder: assertion add '${name2}' missing required 'about'`
-        );
-      }
-      return {
-        operation: "add",
-        kind: kind2,
-        name: name2,
-        about,
-        data: addOp.data ?? {},
-        ...addOp.skipExisting === true ? { skipExisting: true } : {}
-      };
-    }
-    return {
-      operation: "add",
-      kind: kind2,
-      name: name2,
-      data: addOp.data ?? {},
-      ...addOp.skipExisting === true ? { skipExisting: true } : {}
-    };
-  }
-  const name = asNonEmptyString(op.name) ?? asNonEmptyString(op.wref);
-  if (!name) {
-    throw new Error(
-      "OperationBuilder: revise operation missing required target ('name' or 'wref')"
-    );
-  }
-  const kind = normalizeReviseKind(op, name);
-  if (kind === "collection") {
-    throw new Error(
-      `OperationBuilder: collection revise is no longer supported \u2014 use retract('${name}') instead`
-    );
-  }
-  return {
-    operation: "revise",
-    kind,
-    name,
-    data: op.data ?? {},
-    ...op.expectedVersion !== void 0 ? { expectedVersion: op.expectedVersion } : {},
-    ...op.leaseId ? { leaseId: op.leaseId } : {}
-  };
-}
-function toPreflightOp(op, kind) {
-  if (op.operation === "add") {
-    return {
-      operation: op.operation,
-      kind,
-      name: op.name,
-      about: getAddAbout(op),
-      type: getCollectionType(op),
-      members: getCollectionMembers(op)
-    };
-  }
-  return {
-    operation: op.operation,
-    kind,
-    name: op.name ?? op.wref
-  };
-}
-function throwAggregatedMessages(messages) {
-  if (messages.length === 0) return;
-  throw new Error(messages.join("; "));
-}
-function preflightCheckCommon(verb, kind, name, data) {
-  const errors = [];
-  const requiresLocalPath = kind === "thing" || kind === "assertion" || kind === "collection" && verb === "REVISE";
-  if (requiresLocalPath) {
-    if (!splitLocalPath(name)) {
-      errors.push(
-        `${verb} ${kind} name must be a local path (Shape/name), got: "${name}"`
-      );
-    }
-  }
-  if (kind === "shape" && (verb === "ADD" || verb === "REVISE") && data !== void 0) {
-    const preflight = shapeDefinitionPreflightError(
-      name,
-      data,
-      verb === "REVISE" ? "revise" : "add"
-    );
-    if (preflight) errors.push(preflight);
-  }
-  return errors;
-}
-function preflightCheckAdd(op, kind) {
-  const messages = [];
-  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))) {
-    messages.push(
-      `ADD assertion '${op.name}' missing required 'about' \u2014 for hierarchical thing names set kind: 'thing' explicitly`
-    );
-  }
-  if (kind !== "collection" && (getCollectionType(op) !== void 0 || getCollectionMembers(op) !== void 0)) {
-    messages.push(
-      `ADD '${op.name}' has collection fields but inferred kind '${kind}' \u2014 collection adds require both 'type' and 'members', or set kind: 'collection'`
-    );
-  }
-  if (kind === "collection") {
-    try {
-      normalizeBackendCollectionAdd(op, "OperationBuilder");
-    } catch (error) {
-      messages.push(error instanceof Error ? error.message : String(error));
-    }
-  }
-  for (const diagnostic of preflightOpDiagnostics(toPreflightOp(op, kind), 0)) {
-    messages.push(diagnostic.message);
-  }
-  throwAggregatedMessages(messages);
-}
-function preflightCheckRevise(kind, name, data) {
-  const messages = [];
-  if (data === void 0) {
-    messages.push(`OperationBuilder: ${kind} revise requires 'data'`);
-  }
-  messages.push(
-    ...preflightCheckCommon("REVISE", kind, name, data),
-    ...preflightOpDiagnostics(
-      toPreflightOp({ operation: "revise", name, data }, kind),
-      0
-    ).map((diagnostic) => diagnostic.message)
-  );
-  throwAggregatedMessages(messages);
-}
 
 // src/index.ts
 function normalizeWref(wref) {
@@ -9246,7 +9279,8 @@ var WARMHUB_CLIENT_OPTION_NAMES = [
   "fetch",
   "accessToken",
   "auth",
-  "functionLogs"
+  "functionLogs",
+  "client"
 ];
 var WARMHUB_CLIENT_OPTION_NAME_SET = new Set(
   WARMHUB_CLIENT_OPTION_NAMES
@@ -9264,7 +9298,7 @@ function validateWarmHubClientOptions(options) {
     throw new TypeError(`Unknown WarmHubClient option "${key}"${hint}`);
   }
 }
-var SDK_VERSION = "0.60.1" ;
+var SDK_VERSION = "0.61.0" ;
 var DEFAULT_API_URL = "https://api.warmhub.ai";
 var UNBATCHED_TRPC_PATHS = /* @__PURE__ */ new Set([
   "repo.shapeInstanceCounts",
@@ -9599,6 +9633,8 @@ var WarmHubClient = class _WarmHubClient {
   apiUrl;
   fetchImpl;
   accessToken;
+  /** Resolved `X-WarmHub-Client` identity; defaults to this SDK's name/version. */
+  clientIdentity;
   functionLogMode;
   getToken;
   // Cached promise for diagnostics.assertCompatible(). Stored at instance
@@ -10515,21 +10551,6 @@ var WarmHubClient = class _WarmHubClient {
         throw toWarmHubError(error);
       }
     },
-    /**
-     * Immediately and irreversibly purge a repository.
-     *
-     * This owner-only operation has no grace window and uses the same inbound-reference guard as `delete`.
-     */
-    hardDelete: async (orgName, repoName) => {
-      try {
-        await this.trpc.repo.hardDelete.mutate({
-          orgName,
-          repoName
-        });
-      } catch (error) {
-        throw toWarmHubError(error);
-      }
-    },
     /**
      * List repositories with dashboard-oriented per-repository metadata.
      *
@@ -12162,6 +12183,10 @@ var WarmHubClient = class _WarmHubClient {
     this.fetchImpl = options?.fetch;
     this.accessToken = options?.accessToken ?? options?.auth?.getToken;
     this.functionLogMode = options?.functionLogs ?? "off";
+    this.clientIdentity = {
+      name: options?.client?.name ?? WARMHUB_SDK_CLIENT_NAME,
+      version: options?.client?.version ?? SDK_VERSION
+    };
     if (typeof this.accessToken === "function") {
       const provider = this.accessToken;
       this.getToken = async () => await provider();
@@ -12200,7 +12225,10 @@ var WarmHubClient = class _WarmHubClient {
     return new _WarmHubClient({
       apiUrl: this.apiUrl,
       fetch: this.fetchImpl,
-      accessToken
+      accessToken,
+      // Preserve the client identity so a token-scoped clone (e.g. a CLI clone)
+      // keeps reporting `warmhub-cli/…` rather than reverting to the SDK default.
+      client: this.clientIdentity
     });
   }
   /**
@@ -12278,6 +12306,21 @@ var WarmHubClient = class _WarmHubClient {
       closed
     };
   }
+  /**
+   * Stamp the `X-WarmHub-Client` self-identification header, unless the caller
+   * already set it on the request (a per-request header wins over the default).
+   */
+  applyClientHeader(headers) {
+    if (!headers.has(CLIENT_HEADER)) {
+      headers.set(
+        CLIENT_HEADER,
+        formatClientHeader(
+          this.clientIdentity.name,
+          this.clientIdentity.version
+        )
+      );
+    }
+  }
   async fetchWithAuth(input, init) {
     const fetchImpl = this.fetchImpl ?? globalThis.fetch;
     const headers = new Headers(init?.headers);
@@ -12285,6 +12328,7 @@ var WarmHubClient = class _WarmHubClient {
     if (token) {
       headers.set("authorization", `Bearer ${token}`);
     }
+    this.applyClientHeader(headers);
     const doFetch = async (reqInit) => {
       try {
         return await fetchImpl(input, reqInit);
@@ -12301,6 +12345,7 @@ var WarmHubClient = class _WarmHubClient {
       if (freshToken && freshToken !== token) {
         const retryHeaders = new Headers(init?.headers);
         retryHeaders.set("authorization", `Bearer ${freshToken}`);
+        this.applyClientHeader(retryHeaders);
         return doFetch({ ...init, headers: retryHeaders });
       }
     }
@@ -12470,5 +12515,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-D5A5SSUU.js.map
-//# sourceMappingURL=chunk-D5A5SSUU.js.map
+//# sourceMappingURL=chunk-QS6ABKPJ.js.map
+//# sourceMappingURL=chunk-QS6ABKPJ.js.map