@warmhub/cli 0.95.0 → 0.97.0

package/dist/wh.js

@@ -19421,7 +19421,15 @@ function formatClientHeader(name, version) {
 var DEFAULT_MAX_OPS_PER_STREAM = 1e6;
 var DEFAULT_STREAM_APPEND_CHUNK_SIZE = 1000;
 var MAX_STREAM_APPEND_OPERATION_COUNT = 1e4;
+var MAX_STREAMING_SUBMISSION_LINE_BYTES = 1024 * 1024;
 // ../../packages/rules/src/commit-types.ts
+var COMMIT_OPERATIONS = [
+  "add",
+  "revise",
+  "retract",
+  "reaffirm",
+  "rename"
+];
 var COMMIT_OPERATION_KINDS = [
   "shape",
   "thing",
@@ -42109,47 +42117,41 @@ function normalizeOptionalTypeSpec(spec) {
   return { spec, optionalByType: false };
 }
 
-// ../../packages/rules/src/shape-validation-runtime.ts
-function validatePersistedStringFieldLimits(value, typeDef, errors3, path) {
-  const normalized = normalizeOptionalTypeSpec(typeDef).spec;
+// ../../packages/rules/src/shape-validation-content-limits.ts
+function validatePersistedContentLimits(value, typeDefs, errors3, path) {
+  const declared = normalizedCandidates(typeDefs);
   if (typeof value === "string") {
-    if (isDeclaredStringType(normalized) || isDeclaredWrefType(normalized))
-      return;
-    if (normalized !== undefined)
+    if (declared.length > 0)
       return;
     assertContentFieldWithinLimit(path ?? "<value>", value, errors3);
     return;
   }
   if (Array.isArray(value)) {
-    const elementType = arrayElementType(normalized);
-    if (normalized !== undefined && elementType === undefined && !isDeclaredArrayType(normalized)) {
+    const arrayCandidates = declared.filter(isDeclaredArrayType);
+    if (declared.length > 0 && arrayCandidates.length === 0)
       return;
-    }
+    const elementTypes = definedOnly(arrayCandidates.map(arrayElementType));
     for (let i = 0;i < value.length; i++) {
-      validatePersistedStringFieldLimits(value[i], elementType, errors3, `${path ?? "<value>"}[${i}]`);
+      validatePersistedContentLimits(value[i], elementTypes, errors3, `${path ?? "<value>"}[${i}]`);
     }
     return;
   }
   if (!isPlainObject2(value))
     return;
-  const fields = nestedObjectFields(normalized);
-  if (normalized !== undefined && fields === undefined)
+  const objectCandidates = definedOnly(declared.map(nestedObjectFields));
+  if (declared.length > 0 && objectCandidates.length === 0)
     return;
   for (const [key, nestedValue] of Object.entries(value)) {
     const keyPath = path ? joinFieldPath(path, key) : escapeFieldNameForDisplay(key);
     assertContentFieldWithinLimit(keyPath, key, errors3);
-    validatePersistedStringFieldLimits(nestedValue, fields?.get(key), errors3, keyPath);
+    validatePersistedContentLimits(nestedValue, definedOnly(objectCandidates.map((fields) => fields.get(key))), errors3, keyPath);
   }
 }
-function isDeclaredStringType(typeDef) {
-  if (typeDef === "string")
-    return true;
-  return isTypeSpecObject(typeDef) && typeDef.type === "string";
+function normalizedCandidates(typeDefs) {
+  return definedOnly(typeDefs.map((typeDef) => normalizeOptionalTypeSpec(typeDef).spec));
 }
-function isDeclaredWrefType(typeDef) {
-  if (typeDef === "wref")
-    return true;
-  return isTypeSpecObject(typeDef) && typeDef.type === "wref";
+function definedOnly(values) {
+  return values.filter((value) => value !== undefined);
 }
 function arrayElementType(typeDef) {
   if (Array.isArray(typeDef))
@@ -42538,7 +42540,7 @@ function validateShapeDefinition(data, options = {}) {
   if ("description" in obj && typeof obj.description !== "string") {
     errors3.push('"description" must be a string');
   }
-  validatePersistedStringFieldLimits(obj, undefined, errors3);
+  validatePersistedContentLimits(obj, [], errors3);
   if (errors3.length > 0) {
     return { valid: false, errors: errors3 };
   }
@@ -43382,7 +43384,7 @@ class OperationSourceError extends Error {
   }
 }
 async function submitOperationsViaStream(client, args) {
-  const chunkSize = normalizeChunkSize(args.chunkSize);
+  const chunkSize = normalizeStreamChunkSize(args.chunkSize);
   const submissionId = args.submissionId ?? createOperationEventSubmissionId();
   const streamId = args.streamId ?? submissionId;
   const policy = resolveRetryPolicy(args.retry);
@@ -43482,7 +43484,7 @@ async function submitOperationsViaStream(client, args) {
 async function* normalizedChunks(source, chunkSize, skipExisting) {
   try {
     if (Array.isArray(source)) {
-      const operations = source.map((operation, index) => normalizeOperation(operation, index, skipExisting));
+      const operations = source.map((operation, index) => normalizeStreamOperation(operation, index, skipExisting));
       validateNormalizedOperations(operations, 0);
       for (let start = 0;start < operations.length; start += chunkSize) {
         yield { operations: operations.slice(start, start + chunkSize), start };
@@ -43491,8 +43493,8 @@ async function* normalizedChunks(source, chunkSize, skipExisting) {
     }
     let normalizedCount = 0;
     let buffer = [];
-    for await (const operation of source) {
-      buffer.push(normalizeOperation(operation, normalizedCount, skipExisting));
+    for await (const operation of normalizedOperationSource(source, skipExisting)) {
+      buffer.push(operation);
       normalizedCount += 1;
       if (buffer.length < chunkSize)
         continue;
@@ -43510,7 +43512,7 @@ function preflightedChunk(operations, normalizedCount) {
   validateNormalizedOperations(operations, start);
   return { operations, start };
 }
-function normalizeOperation(operation, index, skipExisting) {
+function normalizeStreamOperation(operation, index, skipExisting) {
   let streamOperation;
   try {
     streamOperation = toBackendStreamOperation(operation);
@@ -43523,6 +43525,57 @@ function normalizeOperation(operation, index, skipExisting) {
   }
   return streamOperation;
 }
+async function* normalizedOperationSource(source, skipExisting) {
+  const iterator = createNormalizedOperationIterator(source, skipExisting);
+  try {
+    while (true) {
+      const next = await iterator.next();
+      if (next.done)
+        return;
+      yield next.value;
+    }
+  } finally {
+    const returned = iterator.returnSourceOnce();
+    if (returned)
+      await returned;
+  }
+}
+function createNormalizedOperationIterator(source, skipExisting) {
+  let sourceIterator;
+  let index = 0;
+  let returned = false;
+  let done = false;
+  const acquire = () => {
+    if (sourceIterator)
+      return sourceIterator;
+    sourceIterator = Symbol.asyncIterator in source ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
+    return sourceIterator;
+  };
+  return {
+    async next() {
+      const next = await acquire().next();
+      if (next.done) {
+        done = true;
+        return { done: true, value: undefined };
+      }
+      const value = normalizeStreamOperation(next.value, index, skipExisting);
+      index += 1;
+      return { done: false, value };
+    },
+    returnSourceOnce() {
+      if (returned)
+        return;
+      returned = true;
+      if (!done)
+        return sourceIterator?.return?.();
+    }
+  };
+}
+function encodeStreamOperation(operation) {
+  return streamOperationEncoder.encode(`${JSON.stringify(operation)}
+`);
+}
+var streamOperationEncoder = new TextEncoder;
 function receiptRepoSeq(receipt) {
   const repoSeq = receipt.event?.repoSeq;
   if (repoSeq === undefined)
@@ -43539,15 +43592,579 @@ function validateNormalizedOperations(operations, indexOffset) {
 function isServerAuthoritativeSequenceDiagnostic(diagnostic) {
   return diagnostic.code === "ILLEGAL_OP_SEQUENCE" && diagnostic.message.includes("Cannot revise then add ");
 }
-function normalizeChunkSize(chunkSize) {
+function normalizeStreamChunkSize(chunkSize) {
   if (!Number.isFinite(chunkSize))
     return DEFAULT_STREAM_CHUNK_SIZE;
   return Math.max(1, Math.min(MAX_STREAM_APPEND_OPERATION_COUNT2, Math.trunc(chunkSize)));
 }
+// ../../packages/sdk-ts/src/streaming-submission-protocol.ts
+var MANIFEST_DOMAIN = "warmhub/streaming-submission-manifest/v1";
+var manifestEncoder = new TextEncoder;
+var digestSchema = exports_external.string().regex(/^sha256:[0-9a-f]{64}$/);
+var positionShape = {
+  type: exports_external.literal("result"),
+  chunkOrdinal: exports_external.number().int().nonnegative(),
+  opIndex: exports_external.number().int().nonnegative(),
+  submissionIndex: exports_external.number().int().nonnegative(),
+  name: exports_external.string()
+};
+var currentOperationSchema = exports_external.enum(COMMIT_OPERATIONS);
+var legacyOperationSchema = exports_external.enum([...COMMIT_OPERATIONS, "noop"]);
+var issueSchema = exports_external.object({ path: exports_external.string(), message: exports_external.string() });
+var warningSchema = exports_external.object({
+  undeclaredFields: exports_external.array(exports_external.string()).optional(),
+  undeclaredFieldsTruncated: exports_external.literal(true).optional(),
+  totalUndeclared: exports_external.number().int().nonnegative().optional(),
+  coalescedWrefs: exports_external.array(exports_external.object({
+    fieldPath: exports_external.string(),
+    wref: exports_external.string(),
+    reason: exports_external.string()
+  })).optional(),
+  coalescedWrefsTruncated: exports_external.literal(true).optional(),
+  totalCoalescedWrefs: exports_external.number().int().nonnegative().optional(),
+  deprecations: exports_external.array(exports_external.object({
+    shape: exports_external.string(),
+    message: exports_external.string(),
+    removalMilestone: exports_external.string()
+  })).optional()
+}).optional();
+var affirmationSchema = exports_external.object({
+  added: exports_external.array(exports_external.string()),
+  removed: exports_external.array(exports_external.string()),
+  ignored: exports_external.array(exports_external.string())
+});
+var legacyErrorDetailsSchema = exports_external.discriminatedUnion("reason", [
+  exports_external.object({
+    reason: exports_external.literal("expected_version_mismatch"),
+    expectedVersion: exports_external.number().int().positive(),
+    currentVersion: exports_external.number().int().positive()
+  }),
+  exports_external.object({
+    reason: exports_external.literal("lease_held"),
+    leaseExpiresAt: exports_external.string().datetime()
+  }),
+  exports_external.object({
+    reason: exports_external.literal("validation_failed"),
+    issues: exports_external.array(issueSchema)
+  }),
+  exports_external.object({
+    reason: exports_external.literal("rate_limit_reset"),
+    retryAfterSeconds: exports_external.number().int().positive(),
+    resetAt: exports_external.string().datetime()
+  }),
+  exports_external.object({
+    reason: exports_external.literal("cursor_fence_unavailable"),
+    cause: exports_external.enum(["not_ready", "below_floor", "above_head"]),
+    retryFromStart: exports_external.literal(true)
+  })
+]);
+var currentErrorDetailsSchema = exports_external.discriminatedUnion("reason", [
+  exports_external.object({
+    reason: exports_external.literal("expected_version_mismatch"),
+    expectedVersion: exports_external.number().int().nonnegative(),
+    currentVersion: exports_external.number().int().nonnegative()
+  }).strict(),
+  exports_external.object({
+    reason: exports_external.literal("lease_held"),
+    leaseExpiresAt: exports_external.string().datetime()
+  }).strict(),
+  exports_external.object({
+    reason: exports_external.literal("validation_failed"),
+    issues: exports_external.array(issueSchema.strict())
+  }).strict(),
+  exports_external.object({
+    reason: exports_external.literal("rate_limit_reset"),
+    retryAfterSeconds: exports_external.number().nonnegative(),
+    resetAt: exports_external.string().datetime()
+  }).strict(),
+  exports_external.object({
+    reason: exports_external.literal("cursor_fence_unavailable"),
+    cause: exports_external.enum(["not_ready", "below_floor", "above_head"]),
+    retryFromStart: exports_external.literal(true)
+  }).strict(),
+  exports_external.object({
+    reason: exports_external.literal("dependency_failed"),
+    producerOpIndexes: exports_external.array(exports_external.number().int().nonnegative()).min(1)
+  }).strict()
+]);
+var currentBaseShape = {
+  ...positionShape,
+  operation: currentOperationSchema,
+  submittedName: exports_external.string().optional(),
+  resolvedName: exports_external.string().optional(),
+  warnings: warningSchema,
+  affirmations: affirmationSchema.optional()
+};
+var resultSchema = exports_external.union([
+  exports_external.object({
+    ...positionShape,
+    operation: legacyOperationSchema.optional(),
+    version: exports_external.number().optional(),
+    dataHash: exports_external.string().optional(),
+    status: exports_external.enum(["success", "noop", "failed"]).optional(),
+    error: exports_external.object({
+      code: exports_external.string(),
+      message: exports_external.string(),
+      details: legacyErrorDetailsSchema.optional()
+    }).optional(),
+    resolvedName: exports_external.string().optional(),
+    retryable: exports_external.boolean().optional(),
+    warnings: warningSchema,
+    affirmations: affirmationSchema.optional()
+  }).passthrough(),
+  exports_external.object({
+    ...currentBaseShape,
+    status: exports_external.enum(["applied", "noop"]),
+    version: exports_external.number().int().positive().optional(),
+    dataHash: exports_external.string().min(1).optional()
+  }).passthrough(),
+  exports_external.object({
+    ...currentBaseShape,
+    status: exports_external.literal("error"),
+    errors: exports_external.array(exports_external.object({
+      code: exports_external.string().min(1),
+      message: exports_external.string(),
+      path: exports_external.string().min(1).optional(),
+      details: currentErrorDetailsSchema.optional(),
+      retryable: exports_external.boolean().optional()
+    }).strict()).min(1)
+  }).passthrough()
+]);
+var operationCountsSchema = exports_external.object({
+  applied: exports_external.number().int().nonnegative(),
+  noop: exports_external.number().int().nonnegative(),
+  failed: exports_external.number().int().nonnegative()
+});
+var groupSchema = exports_external.object({
+  type: exports_external.literal("group"),
+  chunkOrdinal: exports_external.number().int().nonnegative(),
+  eventRequestId: exports_external.string().uuid(),
+  requestDigest: digestSchema,
+  outcome: exports_external.enum(["event", "no_event"]),
+  repoSeq: exports_external.number().int().nonnegative().optional(),
+  operations: operationCountsSchema,
+  manifestDigest: digestSchema
+}).passthrough();
+var summarySchema = exports_external.object({
+  type: exports_external.literal("summary"),
+  submissionId: exports_external.string().uuid(),
+  streamId: exports_external.string().min(1),
+  groupSize: exports_external.number().int().positive(),
+  groups: exports_external.number().int().nonnegative(),
+  operations: operationCountsSchema.extend({
+    total: exports_external.number().int().nonnegative()
+  }),
+  repoSeq: exports_external.object({
+    first: exports_external.number().int().nonnegative().nullable(),
+    last: exports_external.number().int().nonnegative().nullable()
+  }),
+  verdict: exports_external.string().min(1),
+  durationMs: exports_external.number().nonnegative(),
+  truncatedAt: exports_external.object({
+    lineNumber: exports_external.number().int().positive(),
+    message: exports_external.string()
+  }).optional(),
+  manifest: exports_external.object({
+    groups: exports_external.number().int().nonnegative(),
+    digest: digestSchema
+  })
+}).passthrough();
+var errorSchema = exports_external.object({
+  type: exports_external.literal("error"),
+  code: exports_external.string().min(1),
+  message: exports_external.string().optional()
+}).passthrough();
+var rowSchema = exports_external.union([
+  resultSchema,
+  groupSchema,
+  summarySchema,
+  errorSchema
+]);
+var emptyCounts = () => ({ applied: 0, noop: 0, failed: 0 });
+var countsMatch = (left, right) => left.applied === right.applied && left.noop === right.noop && left.failed === right.failed;
+var exactTotalVerdicts = new Set([
+  "complete",
+  "operation-limit-reached",
+  "group-limit-reached"
+]);
+
+class StreamingSubmissionProtocolError extends Error {
+  rowIndex;
+  constructor(message, rowIndex) {
+    super(`Streaming submission protocol error at row ${rowIndex}: ${message}`);
+    this.rowIndex = rowIndex;
+    this.name = "StreamingSubmissionProtocolError";
+  }
+}
+async function sha256(value) {
+  const bytes = manifestEncoder.encode(value);
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  return `sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+async function advanceManifest(previous, chunkOrdinal, requestDigest) {
+  return sha256(`${MANIFEST_DOMAIN}\x00${previous}\x00${chunkOrdinal}\x00${requestDigest}`);
+}
+function resultOutcome(row) {
+  if (row.status === "failed" || row.status === "error")
+    return "failed";
+  if (row.status === "noop" || row.operation === "noop")
+    return "noop";
+  return "applied";
+}
+
+class SequenceValidator {
+  index = 0;
+  groupCount = 0;
+  resultCount = 0;
+  pendingCount = 0;
+  pendingCounts = emptyCounts();
+  totalCounts = emptyCounts();
+  firstRepoSeq = null;
+  lastRepoSeq = null;
+  manifestDigest = sha256(MANIFEST_DOMAIN);
+  terminalSeen = false;
+  accept(row) {
+    const fail = (message) => {
+      throw new StreamingSubmissionProtocolError(message, this.index);
+    };
+    if (this.terminalSeen)
+      fail("No row may follow the terminal row");
+    if (row.type === "result") {
+      if (row.chunkOrdinal !== this.groupCount)
+        fail(`Expected result chunkOrdinal ${this.groupCount}`);
+      if (row.opIndex !== this.pendingCount)
+        fail(`Expected result opIndex ${this.pendingCount}`);
+      if (row.submissionIndex !== this.resultCount)
+        fail(`Expected submissionIndex ${this.resultCount}`);
+      const outcome = resultOutcome(row);
+      this.pendingCounts[outcome] += 1;
+      this.totalCounts[outcome] += 1;
+      this.pendingCount += 1;
+      this.resultCount += 1;
+      this.index += 1;
+      return;
+    }
+    if (row.type === "group") {
+      if (row.chunkOrdinal !== this.groupCount)
+        fail(`Expected group chunkOrdinal ${this.groupCount}`);
+      if (this.pendingCount === 0)
+        fail("A group must close result rows");
+      if (!countsMatch(this.pendingCounts, row.operations))
+        fail("Group operation counters do not match its result rows");
+      return this.acceptGroup(row, fail);
+    }
+    this.terminalSeen = true;
+    if (this.pendingCount > 0)
+      fail("Terminal row cannot close a partial group");
+    if (row.type === "summary") {
+      return this.acceptSummary(row, fail);
+    }
+    this.index += 1;
+  }
+  async acceptGroup(row, fail) {
+    this.manifestDigest = this.manifestDigest.then((previous) => advanceManifest(previous, row.chunkOrdinal, row.requestDigest));
+    if (row.manifestDigest !== await this.manifestDigest)
+      fail("Group manifest digest does not match the receipt chain");
+    if (row.repoSeq !== undefined) {
+      this.firstRepoSeq ??= row.repoSeq;
+      this.lastRepoSeq = row.repoSeq;
+    }
+    this.groupCount += 1;
+    this.pendingCount = 0;
+    this.pendingCounts = emptyCounts();
+    this.index += 1;
+  }
+  async acceptSummary(row, fail) {
+    if (!countsMatch(this.totalCounts, row.operations))
+      fail("Summary operation counters do not match result rows");
+    if (row.groups !== this.groupCount || row.manifest.groups !== this.groupCount)
+      fail("Summary group counters do not match group rows");
+    if (row.manifest.digest !== await this.manifestDigest)
+      fail("Summary manifest digest does not match the receipt chain");
+    if (row.repoSeq.first !== this.firstRepoSeq || row.repoSeq.last !== this.lastRepoSeq)
+      fail("Summary repo sequence does not match group rows");
+    const totalIsInvalid = exactTotalVerdicts.has(row.verdict) ? row.operations.total !== this.resultCount : row.operations.total < this.resultCount;
+    if (totalIsInvalid)
+      fail("Summary total is incompatible with its verdict");
+    if (row.verdict === "truncated-by-parse-error" !== (row.truncatedAt !== undefined))
+      fail("truncatedAt must appear only for a parse-truncated verdict");
+    this.index += 1;
+  }
+  finish() {
+    if (!this.terminalSeen)
+      throw new StreamingSubmissionProtocolError("Response must end with a summary or error row", this.index);
+  }
+}
+function parseRow(line, index) {
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch (cause) {
+    throw new StreamingSubmissionProtocolError(cause instanceof Error ? cause.message : "Invalid JSON", index);
+  }
+  const parsed = rowSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new StreamingSubmissionProtocolError(parsed.error.issues[0]?.message ?? "Malformed row", index);
+  }
+  return parsed.data;
+}
+async function* readStreamingSubmissionRows(response, expectedIdentity) {
+  const reader = response.body?.getReader();
+  if (!reader)
+    throw new StreamingSubmissionProtocolError("Missing response body", 0);
+  const validator = new SequenceValidator;
+  const decoder = new TextDecoder;
+  let buffer = "";
+  let rowIndex = 0;
+  let finished = false;
+  let terminalRow;
+  const consume = (line) => {
+    if (line.endsWith("\r"))
+      line = line.slice(0, -1);
+    if (line.length === 0)
+      throw new StreamingSubmissionProtocolError("Blank response row", rowIndex);
+    const row = parseRow(line, rowIndex);
+    const pending = validator.accept(row);
+    return { pending, row };
+  };
+  const validateIdentity = (row) => {
+    if (row.type === "summary" && expectedIdentity !== undefined && (row.submissionId !== expectedIdentity.submissionId || row.streamId !== expectedIdentity.streamId || row.groupSize !== expectedIdentity.groupSize)) {
+      throw new StreamingSubmissionProtocolError("Summary identity does not match the submission handle", rowIndex);
+    }
+    rowIndex += 1;
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      while (true) {
+        const newline = buffer.indexOf(`
+`);
+        if (newline === -1)
+          break;
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        const { pending, row } = consume(line);
+        if (pending)
+          await pending;
+        validateIdentity(row);
+        if (row.type === "summary" || row.type === "error")
+          terminalRow = row;
+        else
+          yield row;
+      }
+    }
+    buffer += decoder.decode();
+    if (buffer.length > 0) {
+      const { pending, row } = consume(buffer);
+      if (pending)
+        await pending;
+      validateIdentity(row);
+      if (row.type === "summary" || row.type === "error")
+        terminalRow = row;
+      else
+        yield row;
+    }
+    validator.finish();
+    finished = true;
+    if (terminalRow)
+      yield terminalRow;
+  } finally {
+    if (!finished)
+      await reader.cancel().catch(() => {
+        return;
+      });
+    reader.releaseLock();
+  }
+}
+
+// ../../packages/sdk-ts/src/streaming-submission-types.ts
+class StreamingSubmissionOutcomeUnknownError extends Error {
+  code = "STREAMING_SUBMISSION_OUTCOME_UNKNOWN";
+  outcome = "unknown";
+  retryable = false;
+  retryIdentity;
+  cause;
+  constructor(retryIdentity, cause) {
+    super(`Streaming submission outcome is unknown for ${retryIdentity.submissionId}. Reconstruct the original source and copy every retryIdentity field into the next applyStreaming call.`);
+    this.name = "StreamingSubmissionOutcomeUnknownError";
+    this.retryIdentity = retryIdentity;
+    this.cause = cause;
+  }
+}
+
+// ../../packages/sdk-ts/src/streaming-submission-handle.ts
+function normalizedOptional(value) {
+  return value === undefined || value === "" ? undefined : value;
+}
+function supportsStreamingRequests() {
+  const runtime = globalThis;
+  if (runtime.Bun !== undefined)
+    return true;
+  const node = runtime.process?.versions?.node;
+  if (!node)
+    return false;
+  const [major = 0, minor = 0] = node.split(".").map(Number);
+  return major > 22 || major === 22 && minor >= 2;
+}
+function submissionPath(identity2) {
+  const query = new URLSearchParams({
+    submissionId: identity2.submissionId,
+    groupSize: String(identity2.groupSize)
+  });
+  if (identity2.message !== undefined)
+    query.set("message", identity2.message);
+  if (identity2.committer !== undefined)
+    query.set("committer", identity2.committer);
+  return `/api/repos/${encodeURIComponent(identity2.orgName)}/${encodeURIComponent(identity2.repoName)}/streams/${encodeURIComponent(identity2.streamId)}/submissions?${query}`;
+}
+function createRequestBody(source) {
+  const iterator = createNormalizedOperationIterator(source, false);
+  let closed = false;
+  const returnSourceOnce = () => {
+    if (closed)
+      return;
+    closed = true;
+    const returned = iterator.returnSourceOnce();
+    if (returned)
+      Promise.resolve(returned).catch(() => {
+        return;
+      });
+  };
+  const stream = new ReadableStream({
+    async pull(controller) {
+      try {
+        const next = await iterator.next();
+        if (closed)
+          return;
+        if (next.done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(encodeStreamOperation(next.value));
+      } catch (cause) {
+        controller.error(cause);
+        returnSourceOnce();
+      }
+    },
+    cancel() {
+      returnSourceOnce();
+    }
+  });
+  return { stream, returnSourceOnce };
+}
+function linkSignal(input, controller) {
+  if (!input)
+    return () => {
+      return;
+    };
+  const abort = () => controller.abort(input.reason);
+  if (input.aborted)
+    abort();
+  else
+    input.addEventListener("abort", abort, { once: true });
+  return () => input.removeEventListener("abort", abort);
+}
+function createIdentity(input) {
+  const submissionId = input.options?.submissionId ?? createOperationEventSubmissionId();
+  return {
+    orgName: input.orgName,
+    repoName: input.repoName,
+    streamId: input.options.streamId,
+    submissionId,
+    groupSize: normalizeStreamChunkSize(input.options.groupSize),
+    ...normalizedOptional(input.message) !== undefined ? { message: normalizedOptional(input.message) } : {},
+    ...normalizedOptional(input.options?.committer) !== undefined ? { committer: normalizedOptional(input.options?.committer) } : {}
+  };
+}
+function createStreamingSubmissionHandle(input, deps) {
+  if (!input.options.streamId) {
+    throw deps.localError("VALIDATION_ERROR", "Streaming submissions require a non-empty streamId.");
+  }
+  const retryIdentity = createIdentity(input);
+  const controller = new AbortController;
+  let unlink = () => {
+    return;
+  };
+  let iterator;
+  let stopped = false;
+  const consume = async function* () {
+    let dispatched = false;
+    let definiteError = false;
+    let body;
+    try {
+      if (!(deps.runtimeSupported ?? supportsStreamingRequests)()) {
+        throw deps.localError("VALIDATION_ERROR", "Streaming submissions require Bun or Node.js 22.2 or newer.");
+      }
+      unlink = linkSignal(input.options.signal, controller);
+      if (controller.signal.aborted) {
+        throw deps.localError("CANCELLED", "Streaming submission was aborted.");
+      }
+      const prepared = await deps.prepare(submissionPath(retryIdentity));
+      if (controller.signal.aborted) {
+        throw deps.localError("CANCELLED", "Streaming submission was aborted.");
+      }
+      body = createRequestBody(input.operations);
+      dispatched = true;
+      const response = await prepared.dispatch(body.stream, controller.signal);
+      if (!response.ok) {
+        definiteError = true;
+        throw await prepared.httpError(response);
+      }
+      for await (const row of readStreamingSubmissionRows(response, retryIdentity)) {
+        yield row;
+      }
+    } catch (cause) {
+      if (cause instanceof StreamingSubmissionOutcomeUnknownError)
+        throw cause;
+      if (dispatched && !definiteError) {
+        throw new StreamingSubmissionOutcomeUnknownError(retryIdentity, cause);
+      }
+      throw deps.normalizeLocalError(cause);
+    } finally {
+      controller.abort();
+      body?.returnSourceOnce();
+      unlink();
+      stopped = true;
+    }
+  };
+  return {
+    retryIdentity,
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next() {
+      if (stopped)
+        return Promise.resolve({ done: true, value: undefined });
+      iterator ??= consume();
+      return iterator.next();
+    },
+    async return(value) {
+      controller.abort();
+      if (!iterator) {
+        stopped = true;
+        unlink();
+        return { done: true, value };
+      }
+      return iterator.return(value);
+    },
+    async throw(error51) {
+      controller.abort(error51);
+      if (!iterator) {
+        stopped = true;
+        unlink();
+        throw error51;
+      }
+      return iterator.throw(error51);
+    }
+  };
+}
 // ../../packages/sdk-ts/package.json
 var package_default = {
   name: "@warmhub/sdk-ts",
-  version: "0.93.0",
+  version: "0.95.0",
   private: false,
   type: "module",
   description: "The TypeScript SDK for WarmHub — create repos, commit and query data, and compound knowledge with your AI agents.",
@@ -43569,6 +44186,11 @@ var package_default = {
     url: "https://warmhub.ai"
   },
   homepage: "https://docs.warmhub.ai/get-started/quickstart/#connect-via-sdk",
+  repository: {
+    type: "git",
+    url: "https://github.com/warmhub/warmhub-app.git",
+    directory: "packages/sdk-ts"
+  },
   bugs: {
     email: "support@warmhub.ai"
   },
@@ -43584,7 +44206,8 @@ var package_default = {
   ],
   publishConfig: {
     registry: "https://registry.npmjs.org",
-    access: "public"
+    access: "public",
+    tag: "latest"
   },
   exports: {
     ".": {
@@ -43602,7 +44225,7 @@ var package_default = {
   },
   scripts: {
     build: 'if [ "${WARMHUB_TEST_RUNTIME_BUILD:-}" = "1" ]; then bun run build:test-runtime; else bun run build:full; fi',
-    "build:full": "tsc --noEmit && bun run build:runtime && bun run build:types && bun run scripts/inject-doc-links.ts",
+    "build:full": "bun run build:runtime && bun run build:types && bun run scripts/inject-doc-links.ts",
     "build:runtime": "tsup",
     "build:types": "NODE_OPTIONS=--max-old-space-size=4096 tsup --config tsup.dts-core.config.ts && NODE_OPTIONS=--max-old-space-size=4096 tsup --config tsup.dts-checkpoint.config.ts",
     "build:test-runtime": "tsup --config tsup.test-runtime.config.ts",
@@ -44431,6 +45054,11 @@ class WarmHubClient {
         throw toWarmHubError(error51);
       }
     },
+    applyStreaming: (orgName, repoName, message, operations, opts) => createStreamingSubmissionHandle({ orgName, repoName, message, operations, options: opts }, {
+      prepare: async (path) => await this.prepareStreamingSubmissionRequest(path),
+      localError: (code, errorMessage) => new WarmHubError(code, errorMessage),
+      normalizeLocalError: toWarmHubError
+    }),
     getReceipt: async (orgName, repoName, eventRequestId) => {
       try {
         return await this.trpc.commit.getReceipt.query({
@@ -46186,32 +46814,54 @@ class WarmHubClient {
   }
   async requestResponse(path, init) {
     const response = await this.fetchWithAuth(`${this.apiUrl.replace(/\/$/, "")}${path}`, init);
-    if (!response.ok) {
-      let message = `Request failed with status ${response.status}`;
-      let code = httpStatusToWarmHubCode(response.status);
-      let errorCode;
-      let hint;
-      let retryAfter;
-      try {
-        const body = await response.json();
-        if (typeof body.error?.message === "string") {
-          message = body.error.message;
-        }
-        if (typeof body.error?.code === "string") {
-          code = body.error.code;
-          errorCode = body.error.code;
-        }
-        if (typeof body.error?.hint === "string") {
-          hint = body.error.hint;
-        }
-        if (typeof body.error?.retryAfter === "number") {
-          retryAfter = body.error.retryAfter;
-        }
-      } catch {}
-      throw new WarmHubError(code, message, response.status, hint, retryAfter, errorCode);
-    }
+    if (!response.ok)
+      throw await this.httpResponseError(response);
     return response;
   }
+  async prepareStreamingSubmissionRequest(path) {
+    const fetchImpl = this.fetchImpl ?? globalThis.fetch;
+    const headers = new Headers({
+      accept: "application/x-ndjson",
+      "content-type": "application/x-ndjson"
+    });
+    const token = await resolveAccessToken(this.accessToken);
+    if (token)
+      headers.set("authorization", `Bearer ${token}`);
+    this.applyClientHeader(headers);
+    const url2 = `${this.apiUrl.replace(/\/$/, "")}${path}`;
+    return {
+      dispatch: async (body, signal) => await fetchImpl(url2, {
+        method: "POST",
+        headers,
+        body,
+        signal,
+        duplex: "half"
+      }),
+      httpError: async (response) => await this.httpResponseError(response)
+    };
+  }
+  async httpResponseError(response) {
+    let message = `Request failed with status ${response.status}`;
+    let code = httpStatusToWarmHubCode(response.status);
+    let errorCode;
+    let hint;
+    let retryAfter;
+    try {
+      const body = await response.json();
+      if (typeof body.error?.message === "string")
+        message = body.error.message;
+      if (typeof body.error?.code === "string") {
+        code = body.error.code;
+        errorCode = body.error.code;
+      }
+      if (typeof body.error?.hint === "string")
+        hint = body.error.hint;
+      if (typeof body.error?.retryAfter === "number") {
+        retryAfter = body.error.retryAfter;
+      }
+    } catch {}
+    return new WarmHubError(code, message, response.status, hint, retryAfter, errorCode);
+  }
   async requestJson(path, init) {
     const response = await this.requestResponse(path, init);
     return await response.json();
@@ -46756,12 +47406,22 @@ function printCliError(err, errWriter, opts = {}) {
 function fromWh(exit, kind, err, hint = err.hint) {
   return new CliError(exit, kind, err.message, err, hint, undefined, err.errorCode);
 }
-function authCliError(input) {
+function classifyAuthError(input) {
   if (input.code !== "UNAUTHENTICATED" && input.code !== "FORBIDDEN") {
     return;
   }
   const fallbackHint = input.code === "FORBIDDEN" ? "Check credentials and backend permissions." : unauthenticatedHint(input.message);
-  return new CliError(5 /* Auth */, "AUTH", input.message, input.cause, input.hint ?? fallbackHint, undefined, input.backendCode);
+  return {
+    exit: 5 /* Auth */,
+    kind: "AUTH",
+    hint: input.hint ?? fallbackHint
+  };
+}
+function authCliError(input) {
+  const classified = classifyAuthError(input);
+  if (!classified)
+    return;
+  return new CliError(classified.exit, classified.kind, input.message, input.cause, classified.hint, undefined, input.backendCode);
 }
 function usageError(usage, ...examples) {
   const hint = examples.length === 0 ? undefined : examples.length === 1 ? `Example: ${examples[0]}` : `Examples:
@@ -46863,61 +47523,62 @@ var OP_USER_INPUT_CODES = new Set([
   "BUILTIN_SHAPE",
   "DEPENDENCY_FAILED"
 ]);
-function cliErrorFromOpFailure(failure) {
+function classifyOpFailure(failure) {
   const diagnostic = failure.errors?.[0] ?? failure.error;
   const code = diagnostic?.code ?? "BACKEND";
   const message = diagnostic?.message ?? `Operation on "${failure.name}" failed`;
   const errorCode = diagnostic?.code;
-  const make = (exit, kind, hint) => new CliError(exit, kind, message, undefined, hint, undefined, errorCode);
-  const authError = authCliError({
-    code,
-    message,
-    backendCode: errorCode
-  });
+  const classified = (exit, kind, hint) => ({ exit, kind, message, hint, errorCode });
+  const authError = classifyAuthError({ code, message });
   if (authError)
-    return authError;
+    return classified(authError.exit, authError.kind, authError.hint);
   if (CONFLICT_SHAPED_CODES.has(code)) {
-    return make(2 /* UserInput */, "CONFLICT", conflictHint(message, code));
+    return classified(2 /* UserInput */, "CONFLICT", conflictHint(message, code));
   }
   if (OP_USER_INPUT_CODES.has(code)) {
-    return make(2 /* UserInput */, "USER_INPUT");
+    return classified(2 /* UserInput */, "USER_INPUT");
   }
   if (isFieldIndexErrorCode(code)) {
     const exit = code === "FIELD_NOT_INDEXABLE" ? 2 /* UserInput */ : 4 /* Backend */;
-    return make(exit, code);
+    return classified(exit, code);
   }
   if (code === "RATE_LIMITED") {
-    return make(4 /* Backend */, "RATE_LIMITED", "Rate limited. Wait for the Retry-After window before retrying.");
+    return classified(4 /* Backend */, "RATE_LIMITED", "Rate limited. Wait for the Retry-After window before retrying.");
   }
   if (code === "QUERY_TOO_EXPENSIVE") {
-    return make(2 /* UserInput */, "QUERY_TOO_EXPENSIVE", "Narrow the query with a more selective field predicate or retry with a shallower page.");
+    return classified(2 /* UserInput */, "QUERY_TOO_EXPENSIVE", "Narrow the query with a more selective field predicate or retry with a shallower page.");
   }
-  return make(4 /* Backend */, "BACKEND");
+  return classified(4 /* Backend */, "BACKEND");
+}
+function cliErrorFromOpFailure(failure) {
+  const classified = classifyOpFailure(failure);
+  return new CliError(classified.exit, classified.kind, classified.message, undefined, classified.hint, undefined, classified.errorCode);
+}
+function opFailurePriority(failure) {
+  const classified = classifyOpFailure(failure);
+  if (classified.exit === 5 /* Auth */)
+    return 4;
+  if (classified.exit === 2 /* UserInput */)
+    return 3;
+  if (classified.kind === "RATE_LIMITED")
+    return 2;
+  return 1;
+}
+function preferMoreSevereOpFailure(current, candidate) {
+  if (!current || opFailurePriority(candidate) > opFailurePriority(current)) {
+    return candidate;
+  }
+  return current;
 }
 function cliErrorFromAllFailed(failures) {
-  const priorityOf = (err) => {
-    if (err.code === 5 /* Auth */)
-      return 4;
-    if (err.code === 2 /* UserInput */)
-      return 3;
-    if (err.kind === "RATE_LIMITED")
-      return 2;
-    return 1;
-  };
-  let bestErr;
-  let bestPriority = -1;
+  let bestFailure;
   for (const failure of failures) {
     if (!isFailedOpStatus(failure.status))
       continue;
-    const err = cliErrorFromOpFailure(failure);
-    const priority = priorityOf(err);
-    if (priority > bestPriority) {
-      bestErr = err;
-      bestPriority = priority;
-    }
+    bestFailure = preferMoreSevereOpFailure(bestFailure, failure);
   }
-  if (bestErr)
-    return bestErr;
+  if (bestFailure)
+    return cliErrorFromOpFailure(bestFailure);
   return new CliError(4 /* Backend */, "BACKEND", `All ${failures.length} operations failed`);
 }
 function requireSingleOpSuccess(result) {
@@ -55108,6 +55769,12 @@ var createFlags3 = {
   "chunk-size": flag.number({
     description: `Streamed ops per append chunk for --stream or .jsonl --file (default: ${DEFAULT_STREAM_APPEND_CHUNK_SIZE}, max: ${MAX_STREAM_APPEND_OPERATION_COUNT})`
   }),
+  "server-stream": flag.boolean({
+    description: "use the full-duplex server submission transport and emit results as groups commit"
+  }),
+  "group-size": flag.number({
+    description: `operations per server-committed group with --server-stream (default: ${DEFAULT_STREAM_APPEND_CHUNK_SIZE}, max: ${MAX_STREAM_APPEND_OPERATION_COUNT})`
+  }),
   "allow-nul-bytes": flag.boolean({
     description: "Skip the client-side pre-check that rejects literal U+0000 bytes in op data. PostgreSQL `text` columns still cannot store these — use only when the backend storage type is known to tolerate them."
   }),
@@ -55172,6 +55839,21 @@ var createFlags3 = {
   })
 };
 
+// ../../packages/warmhub-cli/src/domains/commit-stream-output-contract-id.ts
+var COMMIT_SUBMIT_STREAM_ROW_SCHEMA_ID = "wh.commit.submit.stream.row/v0.1";
+function identify(row) {
+  if ("schema" in row) {
+    throw new Error("Streaming submission row already defines a schema field");
+  }
+  return { schema: COMMIT_SUBMIT_STREAM_ROW_SCHEMA_ID, ...row };
+}
+function identifyCommitSubmitStreamStart(retryIdentity) {
+  return identify({ type: "start", retryIdentity });
+}
+function identifyCommitSubmitStreamRow(row) {
+  return identify(row);
+}
+
 // ../../packages/warmhub-cli/src/domains/commit-submit-template.ts
 import { writeFile } from "node:fs/promises";
 var WRITE_TEMPLATE_KINDS = ["thing", "assertion"];
@@ -56514,6 +57196,284 @@ var handleSubmit = async (ctx, { flags, args }) => {
   }
 };
 
+// ../../packages/warmhub-cli/src/domains/commit-submit-server-source.ts
+import { createReadStream as createReadStream4 } from "node:fs";
+function parseOperationLine(rawLine, lineNumber, label, allowNulBytes) {
+  const trimmed = rawLine.trim();
+  if (!trimmed)
+    return;
+  const operation = safeParseJson(trimmed, `${label} JSONL line ${lineNumber}`);
+  rejectLegacyLifecycleOperations([operation]);
+  if (!allowNulBytes) {
+    assertNoNulBytes("data" in operation ? operation.data : undefined, `${label} JSONL line ${lineNumber}`);
+  }
+  return operation;
+}
+async function* serverJsonlOperationSource(input, label, allowNulBytes) {
+  const decoder = new TextDecoder;
+  const encoder = new TextEncoder;
+  let pending = new Uint8Array(0);
+  let pendingLength = 0;
+  let lineNumber = 0;
+  const lineLimitError = (atLine = lineNumber + 1) => new CliError(2 /* UserInput */, "USER_INPUT", `${label} JSONL line ${atLine} exceeds the 1 MiB line limit.`, undefined, "wh commit submit --file operations.jsonl --server-stream --stream-id bulk-import --format jsonl --repo acme/world");
+  const append = (bytes) => {
+    const required2 = pendingLength + bytes.length;
+    if (required2 > MAX_STREAMING_SUBMISSION_LINE_BYTES)
+      throw lineLimitError();
+    if (required2 > pending.length) {
+      let capacity = Math.max(1024, pending.length);
+      while (capacity < required2) {
+        capacity = Math.min(MAX_STREAMING_SUBMISSION_LINE_BYTES, capacity * 2);
+      }
+      const grown = new Uint8Array(capacity);
+      grown.set(pending.subarray(0, pendingLength));
+      pending = grown;
+    }
+    pending.set(bytes, pendingLength);
+    pendingLength = required2;
+  };
+  const decodeLine = (bytes) => {
+    const required2 = pendingLength + bytes.length;
+    if (required2 > MAX_STREAMING_SUBMISSION_LINE_BYTES) {
+      throw lineLimitError(lineNumber);
+    }
+    if (pendingLength === 0)
+      return decoder.decode(bytes);
+    append(bytes);
+    const line = decoder.decode(pending.subarray(0, pendingLength));
+    pendingLength = 0;
+    return line;
+  };
+  for await (const chunk of input) {
+    const bytes = typeof chunk === "string" ? encoder.encode(chunk) : chunk;
+    let lineStart = 0;
+    let newline = bytes.indexOf(10, lineStart);
+    while (newline >= 0) {
+      lineNumber += 1;
+      const operation = parseOperationLine(decodeLine(bytes.subarray(lineStart, newline)), lineNumber, label, allowNulBytes);
+      if (operation)
+        yield operation;
+      lineStart = newline + 1;
+      newline = bytes.indexOf(10, lineStart);
+    }
+    append(bytes.subarray(lineStart));
+  }
+  if (pendingLength > 0) {
+    lineNumber += 1;
+    const operation = parseOperationLine(decoder.decode(pending.subarray(0, pendingLength)), lineNumber, label, allowNulBytes);
+    if (operation)
+      yield operation;
+  }
+}
+async function* jsonArrayFileSource(path2, allowNulBytes) {
+  const raw = await readValidationJsonArrayFile(path2);
+  const operations = parseJsonArray(raw, "--file contents");
+  rejectLegacyLifecycleOperations(operations);
+  for (const [index, operation] of operations.entries()) {
+    if (!allowNulBytes) {
+      assertNoNulBytes("data" in operation ? operation.data : undefined, `--file operation ${index + 1}`);
+    }
+    yield operation;
+  }
+}
+function createServerStreamingOperationSource(args) {
+  if (args.source === "--stream") {
+    const input = args.ctx.stdin ?? process.stdin;
+    if (isTTY(input)) {
+      throw new CliError(2 /* UserInput */, "USER_INPUT", "No JSONL operations provided on stdin.", undefined, `printf '%s\\n' '{"operation":"add","kind":"thing","name":"Example/item","data":{}}' | wh commit submit --stream --server-stream --stream-id example --repo acme/world`);
+    }
+    return serverJsonlOperationSource(input, "--stream", args.allowNulBytes);
+  }
+  const path2 = args.file;
+  if (!path2.endsWith(".jsonl")) {
+    return jsonArrayFileSource(path2, args.allowNulBytes);
+  }
+  return async function* () {
+    yield* serverJsonlOperationSource(createReadStream4(path2), "--file", args.allowNulBytes);
+  }();
+}
+
+// ../../packages/warmhub-cli/src/domains/commit-submit-server-stream.ts
+function userInput(message) {
+  throw new CliError(2 /* UserInput */, "USER_INPUT", message, undefined, "wh commit submit --file operations.jsonl --server-stream --stream-id bulk-import --format jsonl --repo acme/world");
+}
+function parseGroupSize(value) {
+  if (value === undefined)
+    return;
+  if (!Number.isInteger(value) || value < 1) {
+    userInput("--group-size must be a positive integer.");
+  }
+  if (value > MAX_STREAM_APPEND_OPERATION_COUNT) {
+    userInput(`--group-size must be at most ${MAX_STREAM_APPEND_OPERATION_COUNT}.`);
+  }
+  return value;
+}
+function resolveSource(flags) {
+  return resolveCommitOperationSource({
+    stream: flags.stream === true,
+    ops: flags.ops !== undefined,
+    file: flags.file !== undefined,
+    add: (flags.add?.length ?? 0) > 0,
+    revise: flags.revise !== undefined,
+    retract: (flags.retract?.length ?? 0) > 0,
+    collection: flags.type !== undefined
+  });
+}
+function assertServerStreamOptions(ctx, flags, source) {
+  if (ctx.dryRun)
+    userInput("--server-stream cannot be combined with --dry-run.");
+  if (ctx.format === "json") {
+    userInput("--server-stream requires pretty output or --format jsonl; --json would buffer the response.");
+  }
+  if (source !== "--stream" && source !== "--file") {
+    userInput("--server-stream requires --stream or --file.");
+  }
+  if (flags["submission-id"] !== undefined && !/^(?:00000000-0000-0000-0000-000000000000|[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})$/i.test(flags["submission-id"])) {
+    userInput("--submission-id must be a UUID.");
+  }
+  const incompatible = [
+    ["--chunk-size", flags["chunk-size"] !== undefined],
+    ["--skip-existing", flags["skip-existing"] === true],
+    ["--progress", flags.progress === true],
+    ["--return-repo-seq", flags["return-repo-seq"] === true],
+    ["--timing-out", flags["timing-out"] !== undefined],
+    ["--include-would-be-body", flags["include-would-be-body"] === true],
+    ["--expected-version", flags["expected-version"] !== undefined],
+    ["--lease-id", flags["lease-id"] !== undefined]
+  ].find(([, present]) => present);
+  if (incompatible) {
+    userInput(`${incompatible[0]} cannot be combined with --server-stream.`);
+  }
+  assertFlagsApplyToCommitSource(source, {
+    data: (flags.data?.length ?? 0) > 0,
+    shape: (flags.shape?.length ?? 0) > 0,
+    about: (flags.about?.length ?? 0) > 0,
+    affirm: (flags.affirm?.length ?? 0) > 0,
+    reason: (flags.reason?.length ?? 0) > 0,
+    kind: (flags.kind?.length ?? 0) > 0,
+    name: flags.name !== undefined,
+    members: flags.members !== undefined
+  });
+  const streamId = flags["stream-id"];
+  if (!streamId)
+    userInput("--server-stream requires --stream-id.");
+  if (source === "--stream")
+    return { source, streamId };
+  const file2 = flags.file;
+  if (!file2)
+    userInput("--server-stream with --file requires a file path.");
+  return { source, file: file2, streamId };
+}
+function recoveryGuidance(identity2) {
+  return `Reconstruct the identical operation source and retry only by copying every field from this retry identity: ${JSON.stringify(identity2)}`;
+}
+function failClosedStreamingOutput(ctx, identity2) {
+  ctx.requestedExitCode = 4 /* Backend */;
+  ctx.err(`Streaming submission output closed before completion. ${recoveryGuidance(identity2)}`);
+}
+async function writeStreamingRow(ctx, row) {
+  writeOutput(ctx, identifyCommitSubmitStreamRow(row), () => renderPrettyStreamingRow(ctx, row));
+  return await ctx.flushOut?.() ?? true;
+}
+function renderPrettyStreamingRow(ctx, row) {
+  const c = ctx.colors;
+  if (row.type === "result") {
+    const failed = isFailedOpStatus(row.status);
+    const marker = failed ? "!" : row.status === "noop" ? "=" : "+";
+    const diagnostic = "errors" in row ? row.errors[0] : ("error" in row) ? row.error : undefined;
+    ctx.out(`  ${marker} ${displayName(c, row.name)}${failed ? ` ${diagnostic?.message ?? diagnostic?.code ?? "failed"}` : ""}`);
+    renderWarningLine(ctx.out, c, ctx.chars, row);
+    return;
+  }
+  if (row.type === "group") {
+    ctx.out(`${c.dim}group ${row.chunkOrdinal}${c.reset} event request ${row.eventRequestId}`);
+    return;
+  }
+  if (row.type === "summary") {
+    ctx.out(`${c.dim}summary${c.reset} ${row.verdict} (${row.operations.applied} applied, ${row.operations.noop} noop, ${row.operations.failed} failed)`);
+    return;
+  }
+  ctx.out(`${c.red}error${c.reset} ${row.code}${row.message ? `: ${row.message}` : ""}`);
+}
+async function runServerStreamingSubmit(ctx, invocation) {
+  const flags = invocation.flags;
+  const sourceKind = resolveSource(flags);
+  const options = assertServerStreamOptions(ctx, flags, sourceKind);
+  const groupSize = parseGroupSize(flags["group-size"]);
+  const { org, repo } = parseOrgRepo(getRepoRef(ctx) ?? invocation.args[0], ctx.config);
+  const operations = options.source === "--stream" ? createServerStreamingOperationSource({
+    source: options.source,
+    ctx,
+    allowNulBytes: flags["allow-nul-bytes"] === true
+  }) : createServerStreamingOperationSource({
+    source: options.source,
+    file: options.file,
+    allowNulBytes: flags["allow-nul-bytes"] === true
+  });
+  const handle = ctx.client.commit.applyStreaming(org, repo, flags.message, operations, {
+    streamId: options.streamId,
+    submissionId: flags["submission-id"],
+    groupSize,
+    committer: flags.committer,
+    signal: ctx.signal
+  });
+  const identity2 = handle.retryIdentity;
+  ctx.err(`streaming submission retry identity ${JSON.stringify(identity2)}`);
+  writeOutput(ctx, identifyCommitSubmitStreamStart(identity2), () => {
+    return;
+  });
+  if (await ctx.flushOut?.() === false) {
+    failClosedStreamingOutput(ctx, identity2);
+    await handle.return?.();
+    return;
+  }
+  let terminal;
+  let bestFailure;
+  try {
+    for await (const row of handle) {
+      if (row.type === "result") {
+        if (isFailedOpStatus(row.status)) {
+          bestFailure = preferMoreSevereOpFailure(bestFailure, row);
+        }
+      } else if (row.type === "summary" || row.type === "error") {
+        terminal = row;
+      }
+      if (!await writeStreamingRow(ctx, row)) {
+        failClosedStreamingOutput(ctx, identity2);
+        return;
+      }
+    }
+  } catch (error51) {
+    if (error51 instanceof StreamingSubmissionOutcomeUnknownError) {
+      throw new CliError(4 /* Backend */, "BACKEND", error51.message, error51, recoveryGuidance(error51.retryIdentity));
+    }
+    throw error51;
+  }
+  if (!terminal) {
+    throw new CliError(4 /* Backend */, "BACKEND", "Streaming submission ended without a terminal row; its outcome is unknown.", undefined, recoveryGuidance(identity2));
+  }
+  if (terminal.type === "error" || terminal.verdict !== "complete") {
+    ctx.requestedExitCode = 4 /* Backend */;
+    ctx.err(`${terminal.type === "error" ? terminal.message ?? terminal.code : `submission stopped with verdict ${terminal.verdict}`}. ${recoveryGuidance(identity2)}`);
+    return;
+  }
+  if (terminal.operations.total > 0 && terminal.operations.applied === 0 && terminal.operations.noop === 0) {
+    const error51 = (bestFailure && cliErrorFromOpFailure(bestFailure)) ?? new CliError(4 /* Backend */, "BACKEND", "All streaming submission operations failed.");
+    ctx.requestedExitCode = error51.code;
+    ctx.err(`${error51.message}. ${recoveryGuidance(identity2)}`);
+  }
+}
+var handleSubmitWithServerStreaming = async (ctx, invocation) => {
+  if (invocation.flags["server-stream"] === true) {
+    await runServerStreamingSubmit(ctx, invocation);
+    return;
+  }
+  if (invocation.flags["group-size"] !== undefined) {
+    userInput("--group-size requires --server-stream.");
+  }
+  await handleSubmit(ctx, invocation);
+};
+
 // ../../packages/warmhub-cli/src/domains/commit-submit-domain.ts
 var COMMIT_DOMAIN = defineDomain({
   name: "commit",
@@ -56544,6 +57504,7 @@ var COMMIT_DOMAIN = defineDomain({
         `wh commit submit --ops '[{"operation":"add","kind":"thing","name":"Session/run-001","data":{}},{"operation":"add","kind":"assertion","name":"HypothesisCandidate/run-001-claim","about":"Session/run-001","data":{}}]' -m "Create session + assertion"`,
         `printf '%s\\n' '{"operation":"add","kind":"thing","name":"Player/alice","data":{"score":1}}' | wh commit submit --stream --stream-id bulk-2026-06-04 --skip-existing --repo acme/world -m "stdin stream"`,
         'wh commit submit --file dataset.jsonl --stream-id bulk-2026-06-04 --skip-existing --progress -m "bulk stream"',
+        'wh commit submit --file dataset.jsonl --server-stream --stream-id bulk-2026-08-14 --group-size 1000 --format jsonl -m "server stream"',
         "wh shape template Session HypothesisCandidate -o ops.json",
         "wh commit submit --type arc --name route --members Location/a,Location/b",
         "wh commit submit --type bond --name peers --members Person/alice,Person/bob",
@@ -56552,9 +57513,10 @@ var COMMIT_DOMAIN = defineDomain({
       notes: [
         "`--dry-run` evaluates the complete bounded input with the real server commit evaluator and makes no durable repository change.",
         "Need to build an ops file? Run `wh shape template <Shape>` to scaffold the JSON from a shape definition, edit the FILL_IN placeholders, then pass it to `--file`.",
-        "Inspect a shape's fields first with `wh thing view <Shape>` before authoring or editing an ops file."
+        "Inspect a shape's fields first with `wh thing view <Shape>` before authoring or editing an ops file.",
+        "`--server-stream` is an opt-in full-duplex transport. It preserves the default aggregate path and requires `--stream-id`; use `--format jsonl` for the versioned row stream."
       ],
-      handler: handleSubmit
+      handler: handleSubmitWithServerStreaming
     }
   }
 });
@@ -56646,7 +57608,7 @@ for (const spec of PRE_TERMINATOR_CONTROLS) {
   if (spec.short)
     CONTROL_SHORTS.set(spec.short, { spec, constant: false });
 }
-function userInput(message, hint) {
+function userInput2(message, hint) {
   return new CliError(2 /* UserInput */, "USER_INPUT", message, undefined, hint);
 }
 function hasAttachedValue(record2) {
@@ -56683,13 +57645,13 @@ function acceptedArgList(method) {
 function unknownArgumentError(method, record2) {
   const accepted = acceptedArgList(method);
   const suffix = record2.ownership === "post-terminator" ? ` (use \`--\` to pass globals as method args, e.g. \`-- --${record2.name} <value>\`)` : "";
-  return userInput(`Unknown argument: --${record2.name}`, `Method '${method.name}' accepts: ${accepted}${suffix}`);
+  return userInput2(`Unknown argument: --${record2.name}`, `Method '${method.name}' accepts: ${accepted}${suffix}`);
 }
 function duplicateError(arg) {
-  return userInput(`Flag --${arg.name} may only be specified once`, `Remove the duplicate occurrence; every spelling of --${arg.name} counts as the same flag.`);
+  return userInput2(`Flag --${arg.name} may only be specified once`, `Remove the duplicate occurrence; every spelling of --${arg.name} counts as the same flag.`);
 }
 function missingValueError(arg) {
-  return userInput(`Flag --${arg.name} requires a value`, arg.type === "string" ? `To pass a value starting with '-', use the attached form: --${arg.name}=<value>` : `Usage: --${arg.name} <${arg.type}>`);
+  return userInput2(`Flag --${arg.name} requires a value`, arg.type === "string" ? `To pass a value starting with '-', use the attached form: --${arg.name}=<value>` : `Usage: --${arg.name} <${arg.type}>`);
 }
 function coerceArg(arg, value) {
   switch (arg.type) {
@@ -56697,7 +57659,7 @@ function coerceArg(arg, value) {
       if (typeof value !== "string") {
         return {
           ok: false,
-          error: userInput(`--${arg.name} requires a string value`)
+          error: userInput2(`--${arg.name} requires a string value`)
         };
       }
       if (arg.pattern) {
@@ -56707,13 +57669,13 @@ function coerceArg(arg, value) {
         } catch {
           return {
             ok: false,
-            error: userInput(`invalid regex pattern for --${arg.name}: /${arg.pattern}/`)
+            error: userInput2(`invalid regex pattern for --${arg.name}: /${arg.pattern}/`)
           };
         }
         if (!pattern.test(value)) {
           return {
             ok: false,
-            error: userInput(`--${arg.name} value '${value}' does not match pattern /${arg.pattern}/`)
+            error: userInput2(`--${arg.name} value '${value}' does not match pattern /${arg.pattern}/`)
           };
         }
       }
@@ -56724,32 +57686,32 @@ function coerceArg(arg, value) {
       if (typeof value === "boolean") {
         return {
           ok: false,
-          error: userInput(`--${arg.name} requires a ${arg.type} value`)
+          error: userInput2(`--${arg.name} requires a ${arg.type} value`)
         };
       }
       const numeric = typeof value === "number" ? Number.isFinite(value) ? value : undefined : typeof value === "string" ? parseCliNumber(value) : undefined;
       if (numeric === undefined) {
         return {
           ok: false,
-          error: userInput(`--${arg.name} value ${quoteUserValue(value)} is not a valid ${arg.type}`)
+          error: userInput2(`--${arg.name} value ${quoteUserValue(value)} is not a valid ${arg.type}`)
         };
       }
       if (arg.type === "integer" && !Number.isInteger(numeric)) {
         return {
           ok: false,
-          error: userInput(`--${arg.name} value ${quoteUserValue(value)} is not an integer`)
+          error: userInput2(`--${arg.name} value ${quoteUserValue(value)} is not an integer`)
         };
       }
       if (arg.min !== undefined && numeric < arg.min) {
         return {
           ok: false,
-          error: userInput(`--${arg.name} value ${numeric} is below min ${arg.min}`)
+          error: userInput2(`--${arg.name} value ${numeric} is below min ${arg.min}`)
         };
       }
       if (arg.max !== undefined && numeric > arg.max) {
         return {
           ok: false,
-          error: userInput(`--${arg.name} value ${numeric} is above max ${arg.max}`)
+          error: userInput2(`--${arg.name} value ${numeric} is above max ${arg.max}`)
         };
       }
       return { ok: true, value: numeric };
@@ -56763,7 +57725,7 @@ function coerceArg(arg, value) {
         return { ok: true, value: false };
       return {
         ok: false,
-        error: userInput(`--${arg.name} requires true|false`)
+        error: userInput2(`--${arg.name} requires true|false`)
       };
     }
   }
@@ -56790,7 +57752,7 @@ function bindComponentMethodArgs(invocation, method) {
       continue;
     if (record2.kind === "malformed-short") {
       claimed.add(record2.index);
-      addError(record2.index, userInput(`Unknown argument: --${record2.source.slice(1)}`, `Method '${method.name}' accepts: ${acceptedArgList(method)}`));
+      addError(record2.index, userInput2(`Unknown argument: --${record2.source.slice(1)}`, `Method '${method.name}' accepts: ${acceptedArgList(method)}`));
       continue;
     }
     if (record2.kind !== "option")
@@ -56844,7 +57806,7 @@ function bindComponentMethodArgs(invocation, method) {
   }
   for (const record2 of invocation.records) {
     if (record2.kind === "positional" && !claimed.has(record2.index) && record2.source !== "--") {
-      addError(record2.index, userInput(`Unexpected argument: '${record2.source}'`, "'wh component exec' accepts at most 2 positional arguments (<component> <method>); pass method inputs as flags"));
+      addError(record2.index, userInput2(`Unexpected argument: '${record2.source}'`, "'wh component exec' accepts at most 2 positional arguments (<component> <method>); pass method inputs as flags"));
     }
   }
   for (const arg of method.args) {
@@ -56860,7 +57822,7 @@ function bindComponentMethodArgs(invocation, method) {
       continue;
     }
     if (arg.required && !invocation.help) {
-      addError(Number.POSITIVE_INFINITY, userInput(`Missing required argument: --${arg.name}`));
+      addError(Number.POSITIVE_INFINITY, userInput2(`Missing required argument: --${arg.name}`));
     }
   }
   indexedErrors.sort((left, right) => left.index - right.index || left.order - right.order);
@@ -60556,7 +61518,7 @@ var PRIME_DOMAIN = defineDomain({
 });
 
 // ../../packages/warmhub-cli/src/domains/repo/checkpoint.ts
-import { createReadStream as createReadStream5 } from "node:fs";
+import { createReadStream as createReadStream6 } from "node:fs";
 import { lstat as lstat3 } from "node:fs/promises";
 
 // ../../packages/sdk-ts/src/repository-checkpoint/types.ts
@@ -60931,7 +61893,7 @@ import { createHash as createHash3 } from "node:crypto";
 
 // ../../packages/sdk-ts/src/repository-checkpoint/identity-sort.ts
 import { once } from "node:events";
-import { createReadStream as createReadStream4, createWriteStream } from "node:fs";
+import { createReadStream as createReadStream5, createWriteStream } from "node:fs";
 import { open as open3, rm } from "node:fs/promises";
 import { join as join10 } from "node:path";
 var CHECKPOINT_IDENTITY_SORT_BUDGET_BYTES = 4 * 1024 * 1024;
@@ -61205,7 +62167,7 @@ class RunCursor {
   #offset = 0;
   current;
   constructor(path2) {
-    this.#stream = createReadStream4(path2, {
+    this.#stream = createReadStream5(path2, {
       highWaterMark: RUN_READ_BUFFER_BYTES
     });
     this.#iterator = this.#stream[Symbol.asyncIterator]();
@@ -61597,8 +62559,8 @@ async function writeAll(handle, bytes) {
     offset += bytesWritten;
   }
 }
-function assertArtifactIntegrity(byteLength, sha256, descriptor) {
-  if (byteLength !== descriptor.byteLength || sha256 !== descriptor.sha256) {
+function assertArtifactIntegrity(byteLength, sha2562, descriptor) {
+  if (byteLength !== descriptor.byteLength || sha2562 !== descriptor.sha256) {
     throw new CliError(4 /* Backend */, "BACKEND", "Downloaded checkpoint artifact did not match its access descriptor.");
   }
 }
@@ -61853,7 +62815,7 @@ var handleVerify = async (ctx, { args }) => {
   }
   try {
     await lstat3(archive);
-    const result = await verifyRepositoryCheckpointArchive(createReadStream5(archive));
+    const result = await verifyRepositoryCheckpointArchive(createReadStream6(archive));
     writeOutput(ctx, result, () => {
       ctx.out(`Checkpoint: ${result.checkpointId}`);
       ctx.out(`Repository sequence: ${result.repoSeq}`);
@@ -66801,7 +67763,7 @@ function resolveLogLevel(flagLevel, env) {
 // package.json
 var package_default3 = {
   name: "@warmhub/cli",
-  version: "0.95.0",
+  version: "0.97.0",
   private: false,
   type: "module",
   description: "The wh CLI for WarmHub — create repos, commit and query data, and compound knowledge with your AI agents.",
@@ -66823,6 +67785,11 @@ var package_default3 = {
     url: "https://warmhub.ai"
   },
   homepage: "https://docs.warmhub.ai/get-started/quickstart/#connect-via-cli",
+  repository: {
+    type: "git",
+    url: "https://github.com/warmhub/warmhub-app.git",
+    directory: "apps/cli"
+  },
   bugs: {
     email: "support@warmhub.ai"
   },
@@ -66838,7 +67805,8 @@ var package_default3 = {
   ],
   publishConfig: {
     registry: "https://registry.npmjs.org",
-    access: "public"
+    access: "public",
+    tag: "latest"
   },
   scripts: {
     build: "bun run scripts/build.ts",
@@ -67420,5 +68388,5 @@ process.exitCode = interceptedExitCode === undefined ? await runPreparedCli(laun
   version: package_default3.version
 }) : interceptedExitCode;
 
-//# debugId=E38898F8C9FABDFA64756E2164756E21
-//# warmhub-cli-build-info {"cliVersion":"0.95.0","sdkVersion":"0.93.0"}
+//# debugId=52246A7D0DA1719964756E2164756E21
+//# warmhub-cli-build-info {"cliVersion":"0.97.0","sdkVersion":"0.95.0"}