@opengeni/sdk 0.48.0 → 0.57.0

package/dist/chunk-VWE2QIVO.js

@@ -0,0 +1,1162 @@
+// src/editable-artifacts/worker/rpc-protocol.ts
+var FRAME_MAGIC = new Uint8Array([79, 71, 65, 87, 82, 80, 67, 49]);
+var FRAME_HEADER_BYTES = 36;
+var FRAME_VERSION = 1;
+var DEFAULT_MAX_METADATA_BYTES = 1024 * 1024;
+var DEFAULT_MAX_SEGMENT_BYTES = 128 * 1024 * 1024;
+var DEFAULT_MAX_TOTAL_SEGMENT_BYTES = 512 * 1024 * 1024;
+var DEFAULT_MAX_SEGMENTS = 4096;
+var DEFAULT_ARTIFACT_WORKER_RPC_LIMITS = Object.freeze({
+  maxMetadataBytes: DEFAULT_MAX_METADATA_BYTES,
+  maxSegmentBytes: DEFAULT_MAX_SEGMENT_BYTES,
+  maxTotalSegmentBytes: DEFAULT_MAX_TOTAL_SEGMENT_BYTES,
+  maxSegments: DEFAULT_MAX_SEGMENTS
+});
+var ArtifactWorkerProtocolError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "ArtifactWorkerProtocolError";
+    this.code = code;
+  }
+};
+function encodeArtifactWorkerRpcMessage(input) {
+  const limits = validateLimits(input.limits ?? DEFAULT_ARTIFACT_WORKER_RPC_LIMITS);
+  const generation = unsignedInt(input.generation, "generation");
+  const requestId = unsignedInt(input.requestId, "requestId");
+  if (generation === 0 || requestId === 0) {
+    throw protocolError("invalid_number", "generation and requestId must be nonzero");
+  }
+  const flags = unsignedInt(input.flags ?? 0, "flags");
+  const kind = unsignedShort(input.kind, "kind");
+  if (!isKnownKind(kind)) throw protocolError("unknown_kind", `unknown RPC kind ${kind}`);
+  const metadata = input.metadata ?? new Uint8Array();
+  if (!(metadata instanceof Uint8Array))
+    throw protocolError("invalid_frame", "metadata must be bytes");
+  if (metadata.byteLength > limits.maxMetadataBytes) {
+    throw protocolError("metadata_too_large", "RPC metadata exceeds its configured byte limit");
+  }
+  const segments = input.segments ?? [];
+  if (!Array.isArray(segments) || segments.length > limits.maxSegments || segments.length > 65535) {
+    throw protocolError("segments_too_large", "RPC segment count exceeds its configured limit");
+  }
+  let totalSegmentBytes = 0;
+  const uniqueSegments = /* @__PURE__ */ new Set();
+  for (const segment of segments) {
+    if (!(segment instanceof ArrayBuffer)) {
+      throw protocolError("invalid_segment", "RPC segments must be transferable ArrayBuffers");
+    }
+    if (segment.byteLength > limits.maxSegmentBytes) {
+      throw protocolError("segment_too_large", "RPC segment exceeds its configured byte limit");
+    }
+    if (uniqueSegments.has(segment)) {
+      throw protocolError("invalid_segment", "RPC segments must not alias one transferable buffer");
+    }
+    uniqueSegments.add(segment);
+    totalSegmentBytes = checkedAdd(totalSegmentBytes, segment.byteLength, "RPC segment bytes");
+    if (totalSegmentBytes > limits.maxTotalSegmentBytes) {
+      throw protocolError("segments_too_large", "RPC segments exceed their aggregate byte limit");
+    }
+  }
+  const segmentTableBytes = checkedMultiply(segments.length, 4, "RPC segment table");
+  const frameBytes = checkedAdd(
+    checkedAdd(FRAME_HEADER_BYTES, metadata.byteLength, "RPC frame"),
+    segmentTableBytes,
+    "RPC frame"
+  );
+  const frame = new Uint8Array(frameBytes);
+  const view = new DataView(frame.buffer);
+  frame.set(FRAME_MAGIC, 0);
+  view.setUint16(8, FRAME_VERSION, true);
+  view.setUint16(10, kind, true);
+  view.setUint32(12, generation, true);
+  view.setUint32(16, requestId, true);
+  view.setUint32(20, flags, true);
+  view.setUint32(24, metadata.byteLength, true);
+  view.setUint16(28, segments.length, true);
+  view.setUint16(30, 0, true);
+  view.setUint32(32, 0, true);
+  frame.set(metadata, FRAME_HEADER_BYTES);
+  let offset = FRAME_HEADER_BYTES + metadata.byteLength;
+  for (const segment of segments) {
+    view.setUint32(offset, segment.byteLength, true);
+    offset += 4;
+  }
+  view.setUint32(32, checksum32(frame), true);
+  return { frame: frame.buffer, segments };
+}
+function decodeArtifactWorkerRpcMessage(input, limitsInput = DEFAULT_ARTIFACT_WORKER_RPC_LIMITS) {
+  const limits = validateLimits(limitsInput);
+  if (!isPlainRecord(input)) throw protocolError("invalid_frame", "RPC message must be a record");
+  const keys = Object.keys(input);
+  if (keys.length !== 2 || !keys.includes("frame") || !keys.includes("segments")) {
+    throw protocolError("invalid_frame", "RPC message contains unknown or missing fields");
+  }
+  const frameBuffer = dataProperty(input, "frame");
+  const rawSegments = dataProperty(input, "segments");
+  if (!(frameBuffer instanceof ArrayBuffer)) {
+    throw protocolError("invalid_frame", "RPC frame must be a transferable ArrayBuffer");
+  }
+  if (!Array.isArray(rawSegments))
+    throw protocolError("invalid_frame", "RPC segments must be an array");
+  if (frameBuffer.byteLength < FRAME_HEADER_BYTES)
+    throw protocolError("truncated", "RPC frame is truncated");
+  if (frameBuffer.byteLength > FRAME_HEADER_BYTES + limits.maxMetadataBytes + limits.maxSegments * 4) {
+    throw protocolError("metadata_too_large", "RPC frame exceeds its configured byte limit");
+  }
+  const frame = new Uint8Array(frameBuffer);
+  for (let index = 0; index < FRAME_MAGIC.length; index += 1) {
+    if (frame[index] !== FRAME_MAGIC[index])
+      throw protocolError("bad_magic", "invalid RPC frame magic");
+  }
+  const view = new DataView(frameBuffer);
+  const version = view.getUint16(8, true);
+  if (version !== FRAME_VERSION) {
+    throw protocolError("unsupported_version", `unsupported RPC frame version ${version}`);
+  }
+  const kind = view.getUint16(10, true);
+  if (!isKnownKind(kind)) throw protocolError("unknown_kind", `unknown RPC kind ${kind}`);
+  const generation = view.getUint32(12, true);
+  const requestId = view.getUint32(16, true);
+  if (generation === 0 || requestId === 0) {
+    throw protocolError("noncanonical", "generation and requestId must be nonzero");
+  }
+  const flags = view.getUint32(20, true);
+  const metadataBytes = view.getUint32(24, true);
+  const segmentCount = view.getUint16(28, true);
+  if (view.getUint16(30, true) !== 0) {
+    throw protocolError("noncanonical", "reserved RPC frame bits are set");
+  }
+  if (metadataBytes > limits.maxMetadataBytes) {
+    throw protocolError("metadata_too_large", "RPC metadata exceeds its configured byte limit");
+  }
+  if (segmentCount > limits.maxSegments || rawSegments.length !== segmentCount) {
+    throw protocolError("invalid_segment", "RPC segment count does not match its frame");
+  }
+  const expectedFrameBytes = checkedAdd(
+    checkedAdd(FRAME_HEADER_BYTES, metadataBytes, "RPC frame"),
+    checkedMultiply(segmentCount, 4, "RPC segment table"),
+    "RPC frame"
+  );
+  if (frame.byteLength !== expectedFrameBytes) {
+    throw protocolError("trailing_bytes", "RPC frame has a truncated or trailing payload");
+  }
+  const expectedChecksum = view.getUint32(32, true);
+  view.setUint32(32, 0, true);
+  const actualChecksum = checksum32(frame);
+  view.setUint32(32, expectedChecksum, true);
+  if (expectedChecksum !== actualChecksum) {
+    throw protocolError("checksum_mismatch", "RPC frame checksum does not match");
+  }
+  const segments = [];
+  const uniqueBuffers = /* @__PURE__ */ new Set([frameBuffer]);
+  let totalSegmentBytes = 0;
+  let tableOffset = FRAME_HEADER_BYTES + metadataBytes;
+  for (let index = 0; index < segmentCount; index += 1) {
+    const expectedBytes = view.getUint32(tableOffset, true);
+    tableOffset += 4;
+    const segment = rawSegments[index];
+    if (!(segment instanceof ArrayBuffer) || segment.byteLength !== expectedBytes) {
+      throw protocolError(
+        "invalid_segment",
+        `RPC segment ${index} does not match its declared length`
+      );
+    }
+    if (uniqueBuffers.has(segment)) {
+      throw protocolError("invalid_segment", "RPC frame and segments must use distinct buffers");
+    }
+    uniqueBuffers.add(segment);
+    if (segment.byteLength > limits.maxSegmentBytes) {
+      throw protocolError("segment_too_large", `RPC segment ${index} exceeds its configured limit`);
+    }
+    totalSegmentBytes = checkedAdd(totalSegmentBytes, segment.byteLength, "RPC segment bytes");
+    if (totalSegmentBytes > limits.maxTotalSegmentBytes) {
+      throw protocolError("segments_too_large", "RPC segments exceed their aggregate byte limit");
+    }
+    segments.push(new Uint8Array(segment));
+  }
+  return {
+    kind,
+    generation,
+    requestId,
+    flags,
+    metadata: frame.slice(FRAME_HEADER_BYTES, FRAME_HEADER_BYTES + metadataBytes),
+    segments
+  };
+}
+function transferListForArtifactWorkerRpcMessage(message) {
+  return [message.frame, ...message.segments];
+}
+function ownedTransferBuffer(bytes) {
+  if (!(bytes instanceof Uint8Array))
+    throw protocolError("invalid_segment", "expected byte segment");
+  return bytes.slice().buffer;
+}
+var ArtifactWorkerBinaryWriter = class {
+  constructor(maximumBytes = DEFAULT_MAX_METADATA_BYTES) {
+    this.maximumBytes = maximumBytes;
+    positiveSafeInteger(maximumBytes, "maximumBytes");
+  }
+  chunks = [];
+  size = 0;
+  u8(value) {
+    unsignedByte(value, "u8");
+    return this.append(new Uint8Array([value]));
+  }
+  u16(value) {
+    unsignedShort(value, "u16");
+    const bytes = new Uint8Array(2);
+    new DataView(bytes.buffer).setUint16(0, value, true);
+    return this.append(bytes);
+  }
+  u32(value) {
+    unsignedInt(value, "u32");
+    const bytes = new Uint8Array(4);
+    new DataView(bytes.buffer).setUint32(0, value, true);
+    return this.append(bytes);
+  }
+  safeUint(value) {
+    nonNegativeSafeInteger(value, "safeUint");
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setBigUint64(0, BigInt(value), true);
+    return this.append(bytes);
+  }
+  f64(value) {
+    if (!Number.isFinite(value)) throw protocolError("invalid_number", "f64 must be finite");
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setFloat64(0, value, true);
+    return this.append(bytes);
+  }
+  string(value, maximumBytes = 256 * 1024) {
+    if (typeof value !== "string") throw protocolError("invalid_string", "expected a string");
+    if (!isWellFormedUnicode(value)) {
+      throw protocolError("invalid_string", "string contains an unpaired UTF-16 surrogate");
+    }
+    const bytes = new TextEncoder().encode(value);
+    if (bytes.byteLength > maximumBytes)
+      throw protocolError("string_too_large", "string exceeds its byte limit");
+    this.u32(bytes.byteLength);
+    return this.append(bytes);
+  }
+  optionalString(value, maximumBytes = 256 * 1024) {
+    this.u8(value === null ? 0 : 1);
+    if (value !== null) this.string(value, maximumBytes);
+    return this;
+  }
+  frontier(value, maximumActors = 1024) {
+    const entries = validateFrontier(value, maximumActors);
+    this.u32(entries.length);
+    for (const [actor, counter] of entries) {
+      this.string(actor, 256);
+      this.safeUint(counter);
+    }
+    return this;
+  }
+  finish() {
+    const output = new Uint8Array(this.size);
+    let offset = 0;
+    for (const chunk of this.chunks) {
+      output.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return output;
+  }
+  append(bytes) {
+    this.size = checkedAdd(this.size, bytes.byteLength, "binary metadata");
+    if (this.size > this.maximumBytes) {
+      throw protocolError("metadata_too_large", "binary metadata exceeds its configured limit");
+    }
+    this.chunks.push(bytes);
+    return this;
+  }
+};
+var ArtifactWorkerBinaryReader = class {
+  constructor(bytes) {
+    this.bytes = bytes;
+    if (!(bytes instanceof Uint8Array))
+      throw protocolError("invalid_frame", "metadata must be bytes");
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+  view;
+  offset = 0;
+  u8() {
+    this.require(1);
+    const value = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return value;
+  }
+  u16() {
+    this.require(2);
+    const value = this.view.getUint16(this.offset, true);
+    this.offset += 2;
+    return value;
+  }
+  u32() {
+    this.require(4);
+    const value = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  safeUint() {
+    this.require(8);
+    const value = this.view.getBigUint64(this.offset, true);
+    this.offset += 8;
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw protocolError("invalid_number", "RPC unsigned integer exceeds JavaScript safe range");
+    }
+    return Number(value);
+  }
+  f64() {
+    this.require(8);
+    const value = this.view.getFloat64(this.offset, true);
+    this.offset += 8;
+    if (!Number.isFinite(value)) throw protocolError("invalid_number", "non-finite RPC number");
+    return value;
+  }
+  string(maximumBytes = 256 * 1024) {
+    const length = this.u32();
+    if (length > maximumBytes)
+      throw protocolError("string_too_large", "RPC string exceeds its byte limit");
+    this.require(length);
+    const bytes = this.bytes.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    } catch (error) {
+      throw protocolError("invalid_utf8", "RPC string is not valid UTF-8", error);
+    }
+  }
+  optionalString(maximumBytes = 256 * 1024) {
+    const present = this.u8();
+    if (present === 0) return null;
+    if (present !== 1) throw protocolError("noncanonical", "invalid optional-string tag");
+    return this.string(maximumBytes);
+  }
+  frontier(maximumActors = 1024) {
+    const count = this.u32();
+    if (count > maximumActors)
+      throw protocolError("frontier_too_large", "causal frontier exceeds its actor limit");
+    const entries = [];
+    let previous = "";
+    for (let index = 0; index < count; index += 1) {
+      const actor = this.string(256);
+      if (!actor || index > 0 && compareCodeUnits(previous, actor) >= 0) {
+        throw protocolError(
+          "noncanonical",
+          "causal frontier actors must be unique and code-unit sorted"
+        );
+      }
+      const counter = this.safeUint();
+      entries.push(Object.freeze({ replicaId: actor, counter }));
+      previous = actor;
+    }
+    return Object.freeze(entries);
+  }
+  done() {
+    if (this.offset !== this.bytes.byteLength) {
+      throw protocolError("trailing_bytes", "RPC metadata contains trailing bytes");
+    }
+  }
+  remaining() {
+    return this.bytes.byteLength - this.offset;
+  }
+  require(length) {
+    if (length < 0 || this.offset + length > this.bytes.byteLength) {
+      throw protocolError("truncated", "RPC metadata is truncated");
+    }
+  }
+};
+function validateFrontier(value, maximumActors) {
+  if (!Array.isArray(value))
+    throw protocolError("invalid_frontier", "causal frontier must be an array");
+  const entries = [];
+  for (const entry of value) {
+    if (!isPlainRecord(entry))
+      throw protocolError("invalid_frontier", "causal frontier entry is invalid");
+    const keys = Object.keys(entry);
+    if (keys.length !== 2 || !keys.includes("replicaId") || !keys.includes("counter")) {
+      throw protocolError("invalid_frontier", "causal frontier entry has unknown fields");
+    }
+    const actor = dataProperty(entry, "replicaId");
+    const counter = dataProperty(entry, "counter");
+    if (typeof actor !== "string" || typeof counter !== "number") {
+      throw protocolError("invalid_frontier", "causal frontier entry has invalid fields");
+    }
+    entries.push([actor, counter]);
+  }
+  if (entries.length > maximumActors) {
+    throw protocolError("frontier_too_large", "causal frontier exceeds its actor limit");
+  }
+  for (const [actor, counter] of entries) {
+    if (!actor || new TextEncoder().encode(actor).byteLength > 256) {
+      throw protocolError("invalid_frontier", "causal frontier actor is invalid");
+    }
+    nonNegativeSafeInteger(counter, `causal frontier counter for ${actor}`);
+  }
+  const sorted = entries.slice().sort(([left], [right]) => compareCodeUnits(left, right));
+  for (let index = 0; index < entries.length; index += 1) {
+    if (entries[index][0] !== sorted[index][0]) {
+      throw protocolError("noncanonical", "causal frontier must already be code-unit sorted");
+    }
+    if (index > 0 && entries[index - 1][0] === entries[index][0]) {
+      throw protocolError("noncanonical", "causal frontier contains a duplicate replica");
+    }
+  }
+  return entries;
+}
+function validateLimits(input) {
+  const limits = {
+    maxMetadataBytes: positiveSafeInteger(input.maxMetadataBytes, "maxMetadataBytes"),
+    maxSegmentBytes: positiveSafeInteger(input.maxSegmentBytes, "maxSegmentBytes"),
+    maxTotalSegmentBytes: positiveSafeInteger(input.maxTotalSegmentBytes, "maxTotalSegmentBytes"),
+    maxSegments: positiveSafeInteger(input.maxSegments, "maxSegments")
+  };
+  if (limits.maxSegments > 65535) {
+    throw protocolError("invalid_limit", "maxSegments exceeds the frame encoding limit");
+  }
+  return limits;
+}
+function isKnownKind(kind) {
+  return kind >= 1 /* Initialize */ && kind <= 10 /* QuerySpreadsheet */ || kind === 128 /* Response */ || kind === 129 /* Error */;
+}
+function checksum32(bytes) {
+  let hash = 2166136261;
+  for (const byte of bytes) {
+    hash ^= byte;
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash;
+}
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function isWellFormedUnicode(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      const following = value.charCodeAt(index + 1);
+      if (!(following >= 56320 && following <= 57343)) return false;
+      index += 1;
+    } else if (code >= 56320 && code <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+function isPlainRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function dataProperty(record, key) {
+  const descriptor = Object.getOwnPropertyDescriptor(record, key);
+  if (!descriptor || !("value" in descriptor)) {
+    throw protocolError("invalid_frame", `RPC ${key} must be a data property`);
+  }
+  return descriptor.value;
+}
+function unsignedByte(value, label) {
+  if (!Number.isInteger(value) || value < 0 || value > 255) {
+    throw protocolError("invalid_number", `${label} must be an unsigned byte`);
+  }
+  return value;
+}
+function unsignedShort(value, label) {
+  if (!Number.isInteger(value) || value < 0 || value > 65535) {
+    throw protocolError("invalid_number", `${label} must be an unsigned 16-bit integer`);
+  }
+  return value;
+}
+function unsignedInt(value, label) {
+  if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+    throw protocolError("invalid_number", `${label} must be an unsigned 32-bit integer`);
+  }
+  return value;
+}
+function positiveSafeInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw protocolError("invalid_limit", `${label} must be a positive safe integer`);
+  }
+  return value;
+}
+function nonNegativeSafeInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw protocolError("invalid_number", `${label} must be a non-negative safe integer`);
+  }
+  return value;
+}
+function checkedAdd(left, right, label) {
+  const result = left + right;
+  if (!Number.isSafeInteger(result)) throw protocolError("size_overflow", `${label} overflow`);
+  return result;
+}
+function checkedMultiply(left, right, label) {
+  const result = left * right;
+  if (!Number.isSafeInteger(result)) throw protocolError("size_overflow", `${label} overflow`);
+  return result;
+}
+function protocolError(code, message, cause) {
+  return new ArtifactWorkerProtocolError(
+    code,
+    message,
+    cause === void 0 ? void 0 : { cause }
+  );
+}
+
+// src/editable-artifacts/worker/wire-codec.ts
+import {
+  EDITABLE_ARTIFACT_COMMAND_MAX_BYTES,
+  EDITABLE_ARTIFACT_INTENT_MAX_BYTES,
+  EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES
+} from "@opengeni/contracts/editable-artifacts";
+import { MAX_COMMITTED_TRANSACTION_BYTES } from "@opengeni/contracts/editable-artifact-committed-transaction";
+var MAX_ID_BYTES = 256;
+var MAX_VERSION_BYTES = 512;
+var MAX_ERROR_BYTES = 8 * 1024;
+var MAX_URL_BYTES = 8 * 1024;
+var SHA256_PATTERN = /^sha256:[0-9a-f]{64}$/;
+var HARD_MAX_SNAPSHOT_BYTES = EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES;
+var HARD_MAX_COMMAND_BYTES = EDITABLE_ARTIFACT_COMMAND_MAX_BYTES;
+var HARD_MAX_INTENT_BYTES = EDITABLE_ARTIFACT_INTENT_MAX_BYTES;
+var HARD_MAX_COMMITTED_TRANSACTION_BYTES = MAX_COMMITTED_TRANSACTION_BYTES;
+var HARD_MAX_QUERY_BYTES = 256;
+var HARD_MAX_QUERY_RESPONSE_BYTES = 8 * 1024 * 1024;
+var HARD_MAX_PENDING_TRANSACTIONS = 1024;
+function encodeInitialize(input) {
+  validateInitializeLimits(input);
+  const writer = new ArtifactWorkerBinaryWriter();
+  writer.u8(modalityTag(input.modality)).string(requireVersion(input.kernelVersion, "kernelVersion"), MAX_VERSION_BYTES).u32(positiveSafeInteger2(input.protocolVersion, "protocolVersion")).u32(positiveSafeInteger2(input.modelSchemaVersion, "modelSchemaVersion")).u32(positiveSafeInteger2(input.commandVersion, "commandVersion")).string(requireUrl(input.wasmGlueUrl, "wasmGlueUrl"), MAX_URL_BYTES).string(requireUrl(input.wasmBinaryUrl, "wasmBinaryUrl"), MAX_URL_BYTES).safeUint(positiveSafeInteger2(input.maximumSnapshotBytes, "maximumSnapshotBytes")).safeUint(positiveSafeInteger2(input.maximumCommandBytes, "maximumCommandBytes")).safeUint(positiveSafeInteger2(input.maximumIntentBytes, "maximumIntentBytes")).safeUint(
+    positiveSafeInteger2(
+      input.maximumCommittedTransactionBytes,
+      "maximumCommittedTransactionBytes"
+    )
+  ).safeUint(positiveSafeInteger2(input.maximumQueryBytes, "maximumQueryBytes")).safeUint(positiveSafeInteger2(input.maximumQueryResponseBytes, "maximumQueryResponseBytes")).safeUint(positiveSafeInteger2(input.maximumPendingTransactions, "maximumPendingTransactions"));
+  return writer.finish();
+}
+function decodeInitialize(bytes) {
+  const reader = new ArtifactWorkerBinaryReader(bytes);
+  const value = {
+    modality: decodeModality(reader.u8()),
+    kernelVersion: requireVersion(reader.string(MAX_VERSION_BYTES), "kernelVersion"),
+    protocolVersion: positiveSafeInteger2(reader.u32(), "protocolVersion"),
+    modelSchemaVersion: positiveSafeInteger2(reader.u32(), "modelSchemaVersion"),
+    commandVersion: positiveSafeInteger2(reader.u32(), "commandVersion"),
+    wasmGlueUrl: requireUrl(reader.string(MAX_URL_BYTES), "wasmGlueUrl"),
+    wasmBinaryUrl: requireUrl(reader.string(MAX_URL_BYTES), "wasmBinaryUrl"),
+    maximumSnapshotBytes: positiveSafeInteger2(reader.safeUint(), "maximumSnapshotBytes"),
+    maximumCommandBytes: positiveSafeInteger2(reader.safeUint(), "maximumCommandBytes"),
+    maximumIntentBytes: positiveSafeInteger2(reader.safeUint(), "maximumIntentBytes"),
+    maximumCommittedTransactionBytes: positiveSafeInteger2(
+      reader.safeUint(),
+      "maximumCommittedTransactionBytes"
+    ),
+    maximumQueryBytes: positiveSafeInteger2(reader.safeUint(), "maximumQueryBytes"),
+    maximumQueryResponseBytes: positiveSafeInteger2(reader.safeUint(), "maximumQueryResponseBytes"),
+    maximumPendingTransactions: positiveSafeInteger2(
+      reader.safeUint(),
+      "maximumPendingTransactions"
+    )
+  };
+  reader.done();
+  validateInitializeLimits(value);
+  return value;
+}
+function encodeSnapshotMetadata(snapshot) {
+  const writer = new ArtifactWorkerBinaryWriter();
+  writer.u8(modalityTag(snapshot.modality)).string(requireIdentifier(snapshot.artifactId, "snapshot.artifactId"), MAX_ID_BYTES).safeUint(nonNegativeSafeInteger2(snapshot.sequence, "snapshot.sequence")).string(requireSha256(snapshot.stateHash, "snapshot.stateHash"), 71).string(requireSha256(snapshot.digest, "snapshot.digest"), 71).string(requireVersion(snapshot.kernelVersion, "snapshot.kernelVersion"), MAX_VERSION_BYTES).u32(positiveSafeInteger2(snapshot.modelSchemaVersion, "snapshot.modelSchemaVersion"));
+  if (snapshot.modality === "spreadsheet") {
+    writer.frontier(snapshot.causalFrontier).u32(positiveSafeInteger2(snapshot.protocolVersion, "snapshot.protocolVersion"));
+  } else {
+    writer.safeUint(nonNegativeSafeInteger2(snapshot.nativeRevision, "snapshot.nativeRevision"));
+  }
+  return writer.finish();
+}
+function decodeSnapshotMetadata(bytes, snapshotBytes) {
+  const reader = new ArtifactWorkerBinaryReader(bytes);
+  const modality = decodeModality(reader.u8());
+  const common = {
+    artifactId: requireIdentifier(reader.string(MAX_ID_BYTES), "snapshot.artifactId"),
+    sequence: nonNegativeSafeInteger2(reader.safeUint(), "snapshot.sequence"),
+    stateHash: requireSha256(reader.string(71), "snapshot.stateHash"),
+    digest: requireSha256(reader.string(71), "snapshot.digest"),
+    kernelVersion: requireVersion(reader.string(MAX_VERSION_BYTES), "snapshot.kernelVersion"),
+    modelSchemaVersion: positiveSafeInteger2(reader.u32(), "snapshot.modelSchemaVersion"),
+    bytes: snapshotBytes
+  };
+  const value = modality === "spreadsheet" ? {
+    ...common,
+    modality,
+    causalFrontier: reader.frontier(),
+    protocolVersion: positiveSafeInteger2(reader.u32(), "snapshot.protocolVersion")
+  } : {
+    ...common,
+    modality,
+    nativeRevision: nonNegativeSafeInteger2(reader.safeUint(), "snapshot.nativeRevision")
+  };
+  reader.done();
+  return Object.freeze(value);
+}
+function encodeCommittedMetadata(transaction) {
+  const writer = new ArtifactWorkerBinaryWriter();
+  encodeCommittedFields(writer, transaction);
+  return writer.finish();
+}
+function decodeCommittedMetadata(bytes, committedTransactionBytes) {
+  const reader = new ArtifactWorkerBinaryReader(bytes);
+  const modality = decodeModality(reader.u8());
+  const common = {
+    artifactId: requireIdentifier(reader.string(MAX_ID_BYTES), "transaction.artifactId"),
+    transactionId: requireIdentifier(reader.string(MAX_ID_BYTES), "transaction.transactionId"),
+    requestHash: requireSha256(reader.string(71), "transaction.requestHash"),
+    startSequence: positiveSafeInteger2(reader.safeUint(), "transaction.startSequence"),
+    endSequence: positiveSafeInteger2(reader.safeUint(), "transaction.endSequence"),
+    priorStateHash: requireSha256(reader.string(71), "transaction.priorStateHash"),
+    stateHash: requireSha256(reader.string(71), "transaction.stateHash"),
+    committedTransactionBytes
+  };
+  const value = modality === "spreadsheet" ? {
+    ...common,
+    modality,
+    causalFrontier: reader.frontier(),
+    protocolVersion: positiveSafeInteger2(reader.u32(), "transaction.protocolVersion")
+  } : {
+    ...common,
+    modality,
+    priorNativeRevision: nonNegativeSafeInteger2(
+      reader.safeUint(),
+      "transaction.priorNativeRevision"
+    ),
+    nativeRevision: nonNegativeSafeInteger2(reader.safeUint(), "transaction.nativeRevision"),
+    commitProtocolVersion: positiveSafeInteger2(
+      reader.u32(),
+      "transaction.commitProtocolVersion"
+    )
+  };
+  reader.done();
+  if (value.endSequence < value.startSequence) {
+    throw wireError("invalid_sequence", "transaction endSequence precedes startSequence");
+  }
+  return Object.freeze(value);
+}
+function encodePendingListMetadata(transactions) {
+  const writer = new ArtifactWorkerBinaryWriter();
+  if (!Array.isArray(transactions))
+    throw wireError("invalid_pending", "pending transactions must be an array");
+  writer.u32(transactions.length);
+  for (const transaction of transactions) encodePendingFields(writer, transaction);
+  return writer.finish();
+}
+function decodePendingListMetadata(bytes, segments, maximumTransactions) {
+  const reader = new ArtifactWorkerBinaryReader(bytes);
+  const count = reader.u32();
+  if (count > maximumTransactions || count * 2 !== segments.length) {
+    throw wireError("invalid_pending", "pending metadata and command segments do not match");
+  }
+  const transactions = [];
+  for (let index = 0; index < count; index += 1) {
+    transactions.push(decodePendingFields(reader, segments[index * 2], segments[index * 2 + 1]));
+  }
+  reader.done();
+  return Object.freeze(transactions);
+}
+function encodeReconcileMetadata(committed, pending) {
+  const writer = new ArtifactWorkerBinaryWriter();
+  encodeCommittedFields(writer, committed);
+  writer.u32(pending.length);
+  for (const transaction of pending) encodePendingFields(writer, transaction);
+  return writer.finish();
+}
+function decodeReconcileMetadata(bytes, segments, maximumPendingTransactions) {
+  if (segments.length < 1) throw wireError("invalid_segment", "reconcile requires operation bytes");
+  const reader = new ArtifactWorkerBinaryReader(bytes);
+  const committed = decodeCommittedFields(reader, segments[0]);
+  if (committed.endSequence < committed.startSequence) {
+    throw wireError("invalid_sequence", "transaction endSequence precedes startSequence");
+  }
+  const count = reader.u32();
+  if (count > maximumPendingTransactions || segments.length !== count * 2 + 1) {
+    throw wireError("invalid_pending", "reconcile pending metadata and segments do not match");
+  }
+  const pending = [];
+  for (let index = 0; index < count; index += 1) {
+    pending.push(decodePendingFields(reader, segments[index * 2 + 1], segments[index * 2 + 2]));
+  }
+  reader.done();
+  return { committed, pending: Object.freeze(pending) };
+}
+function encodeAuthorPendingMetadata(input) {
+  const writer = new ArtifactWorkerBinaryWriter();
+  encodeAuthorPendingFields(writer, input);
+  return writer.finish();
+}
+function decodeAuthorPendingMetadata(bytes, commandBytes) {
+  const reader = new ArtifactWorkerBinaryReader(bytes);
+  const value = decodeAuthorPendingFields(reader, commandBytes);
+  reader.done();
+  return value;
+}
+function encodeStateResponse(stateHash, digest) {
+  const writer = new ArtifactWorkerBinaryWriter(256);
+  writer.string(requireSha256(stateHash, "stateHash"), 71).optionalString(digest === void 0 ? null : requireSha256(digest, "digest"), 71);
+  return writer.finish();
+}
+function decodeStateResponse(bytes) {
+  const reader = new ArtifactWorkerBinaryReader(bytes);
+  const stateHash = requireSha256(reader.string(71), "stateHash");
+  const digest = reader.optionalString(71);
+  reader.done();
+  return digest === null ? { stateHash } : { stateHash, digest: requireSha256(digest, "digest") };
+}
+function encodeProjectionResponse(blockedPending, stateHash) {
+  if (!Array.isArray(blockedPending) || blockedPending.length > HARD_MAX_PENDING_TRANSACTIONS) {
+    throw wireError("invalid_pending", "blocked pending result exceeds its item limit");
+  }
+  const writer = new ArtifactWorkerBinaryWriter();
+  writer.optionalString(stateHash === void 0 ? null : requireSha256(stateHash, "stateHash"), 71);
+  writer.u32(blockedPending.length);
+  const seen = /* @__PURE__ */ new Set();
+  for (const blocked of blockedPending) {
+    const clientTransactionId = requireIdentifier(
+      blocked.clientTransactionId,
+      "blocked.clientTransactionId"
+    );
+    if (seen.has(clientTransactionId))
+      throw wireError("noncanonical", "blocked transaction is duplicated");
+    seen.add(clientTransactionId);
+    writer.string(clientTransactionId, MAX_ID_BYTES).string(requireErrorCode(blocked.code), 128);
+  }
+  return writer.finish();
+}
+function decodeProjectionResponse(bytes) {
+  const reader = new ArtifactWorkerBinaryReader(bytes);
+  const stateHash = reader.optionalString(71);
+  const count = reader.u32();
+  if (count > HARD_MAX_PENDING_TRANSACTIONS) {
+    throw wireError("invalid_pending", "blocked pending result exceeds its item limit");
+  }
+  const blockedPending = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let index = 0; index < count; index += 1) {
+    const clientTransactionId = requireIdentifier(
+      reader.string(MAX_ID_BYTES),
+      "blocked.clientTransactionId"
+    );
+    if (seen.has(clientTransactionId))
+      throw wireError("noncanonical", "blocked transaction is duplicated");
+    seen.add(clientTransactionId);
+    blockedPending.push(
+      Object.freeze({ clientTransactionId, code: requireErrorCode(reader.string(128)) })
+    );
+  }
+  reader.done();
+  return {
+    ...stateHash === null ? {} : { stateHash: requireSha256(stateHash, "stateHash") },
+    blockedPending: Object.freeze(blockedPending)
+  };
+}
+function encodeErrorPayload(error) {
+  const writer = new ArtifactWorkerBinaryWriter(MAX_ERROR_BYTES * 2 + 32);
+  writer.string(requireErrorCode(error.code), 128).string(requireBoundedString(error.message, "error.message", MAX_ERROR_BYTES), MAX_ERROR_BYTES).u8(error.retryable ? 1 : 0);
+  return writer.finish();
+}
+function decodeErrorPayload(bytes) {
+  const reader = new ArtifactWorkerBinaryReader(bytes);
+  const value = {
+    code: requireErrorCode(reader.string(128)),
+    message: requireBoundedString(reader.string(MAX_ERROR_BYTES), "error.message", MAX_ERROR_BYTES),
+    retryable: decodeBoolean(reader.u8(), "error.retryable")
+  };
+  reader.done();
+  return value;
+}
+function sha256Hex(bytes) {
+  if (!(bytes instanceof Uint8Array))
+    throw wireError("invalid_bytes", "SHA-256 input must be bytes");
+  const owned = new Uint8Array(bytes);
+  return globalThis.crypto.subtle.digest("SHA-256", owned).then(
+    (digest) => `sha256:${[...new Uint8Array(digest)].map((value) => value.toString(16).padStart(2, "0")).join("")}`
+  );
+}
+function requireMatchingHash(actual, expected, label) {
+  requireSha256(actual, `${label}.actual`);
+  requireSha256(expected, `${label}.expected`);
+  if (actual !== expected)
+    throw wireError("kernel_diverged", `${label} hash does not match authority`);
+}
+function encodeCommittedFields(writer, transaction) {
+  writer.u8(modalityTag(transaction.modality)).string(requireIdentifier(transaction.artifactId, "transaction.artifactId"), MAX_ID_BYTES).string(requireIdentifier(transaction.transactionId, "transaction.transactionId"), MAX_ID_BYTES).string(requireSha256(transaction.requestHash, "transaction.requestHash"), 71).safeUint(positiveSafeInteger2(transaction.startSequence, "transaction.startSequence")).safeUint(positiveSafeInteger2(transaction.endSequence, "transaction.endSequence")).string(requireSha256(transaction.priorStateHash, "transaction.priorStateHash"), 71).string(requireSha256(transaction.stateHash, "transaction.stateHash"), 71);
+  if (transaction.modality === "spreadsheet") {
+    writer.frontier(transaction.causalFrontier).u32(positiveSafeInteger2(transaction.protocolVersion, "transaction.protocolVersion"));
+  } else {
+    writer.safeUint(
+      nonNegativeSafeInteger2(transaction.priorNativeRevision, "transaction.priorNativeRevision")
+    ).safeUint(nonNegativeSafeInteger2(transaction.nativeRevision, "transaction.nativeRevision")).u32(
+      positiveSafeInteger2(transaction.commitProtocolVersion, "transaction.commitProtocolVersion")
+    );
+  }
+}
+function decodeCommittedFields(reader, committedTransactionBytes) {
+  const modality = decodeModality(reader.u8());
+  const common = {
+    artifactId: requireIdentifier(reader.string(MAX_ID_BYTES), "transaction.artifactId"),
+    transactionId: requireIdentifier(reader.string(MAX_ID_BYTES), "transaction.transactionId"),
+    requestHash: requireSha256(reader.string(71), "transaction.requestHash"),
+    startSequence: positiveSafeInteger2(reader.safeUint(), "transaction.startSequence"),
+    endSequence: positiveSafeInteger2(reader.safeUint(), "transaction.endSequence"),
+    priorStateHash: requireSha256(reader.string(71), "transaction.priorStateHash"),
+    stateHash: requireSha256(reader.string(71), "transaction.stateHash"),
+    committedTransactionBytes
+  };
+  return Object.freeze(
+    modality === "spreadsheet" ? {
+      ...common,
+      modality,
+      causalFrontier: reader.frontier(),
+      protocolVersion: positiveSafeInteger2(reader.u32(), "transaction.protocolVersion")
+    } : {
+      ...common,
+      modality,
+      priorNativeRevision: nonNegativeSafeInteger2(
+        reader.safeUint(),
+        "transaction.priorNativeRevision"
+      ),
+      nativeRevision: nonNegativeSafeInteger2(reader.safeUint(), "transaction.nativeRevision"),
+      commitProtocolVersion: positiveSafeInteger2(
+        reader.u32(),
+        "transaction.commitProtocolVersion"
+      )
+    }
+  );
+}
+function modalityTag(modality) {
+  switch (modality) {
+    case "document":
+      return 1;
+    case "spreadsheet":
+      return 2;
+    case "presentation":
+      return 3;
+  }
+}
+function decodeModality(tag) {
+  if (tag === 1) return "document";
+  if (tag === 2) return "spreadsheet";
+  if (tag === 3) return "presentation";
+  throw wireError("invalid_modality", "artifact modality tag is invalid");
+}
+function encodePendingFields(writer, transaction) {
+  writer.u8(modalityTag(transaction.modality)).string(requireIdentifier(transaction.artifactId, "pending.artifactId"), MAX_ID_BYTES).string(
+    requireIdentifier(transaction.clientTransactionId, "pending.clientTransactionId"),
+    MAX_ID_BYTES
+  ).string(requireSha256(transaction.requestHash, "pending.requestHash"), 71).u32(positiveSafeInteger2(transaction.protocolVersion, "pending.protocolVersion")).u32(positiveSafeInteger2(transaction.modelSchemaVersion, "pending.modelSchemaVersion")).u32(positiveSafeInteger2(transaction.commandVersion, "pending.commandVersion")).string(requireReplicaId(transaction.replicaId, "pending.replicaId"), 16).safeUint(positiveSafeInteger2(transaction.replicaCounter, "pending.replicaCounter")).optionalString(
+    transaction.previousLocalTransactionId === null ? null : requireIdentifier(
+      transaction.previousLocalTransactionId,
+      "pending.previousLocalTransactionId"
+    ),
+    MAX_ID_BYTES
+  ).safeUint(
+    nonNegativeSafeInteger2(transaction.observedHeadSequence, "pending.observedHeadSequence")
+  );
+  if (transaction.modality === "spreadsheet") {
+    writer.frontier(transaction.causalBase).u32(transaction.selectiveUndoTargets.length);
+    encodeSortedIdentifiers(
+      writer,
+      transaction.selectiveUndoTargets,
+      "pending.selectiveUndoTargets"
+    );
+  } else {
+    writer.safeUint(
+      nonNegativeSafeInteger2(transaction.observedNativeRevision, "pending.observedNativeRevision")
+    );
+  }
+  writer.safeUint(nonNegativeSafeInteger2(transaction.createdAt, "pending.createdAt"));
+}
+function decodePendingFields(reader, commandBytes, intentBytes) {
+  const modality = decodeModality(reader.u8());
+  const artifactId = requireIdentifier(reader.string(MAX_ID_BYTES), "pending.artifactId");
+  const clientTransactionId = requireIdentifier(
+    reader.string(MAX_ID_BYTES),
+    "pending.clientTransactionId"
+  );
+  const requestHash = requireSha256(reader.string(71), "pending.requestHash");
+  const protocolVersion = positiveSafeInteger2(reader.u32(), "pending.protocolVersion");
+  const modelSchemaVersion = positiveSafeInteger2(reader.u32(), "pending.modelSchemaVersion");
+  const commandVersion = positiveSafeInteger2(reader.u32(), "pending.commandVersion");
+  const replicaId = requireReplicaId(reader.string(16), "pending.replicaId");
+  const replicaCounter = positiveSafeInteger2(reader.safeUint(), "pending.replicaCounter");
+  const previousLocalTransactionId = optionalIdentifier(
+    reader.optionalString(MAX_ID_BYTES),
+    "pending.previousLocalTransactionId"
+  );
+  const observedHeadSequence = nonNegativeSafeInteger2(
+    reader.safeUint(),
+    "pending.observedHeadSequence"
+  );
+  const common = {
+    artifactId,
+    clientTransactionId,
+    requestHash,
+    protocolVersion,
+    modelSchemaVersion,
+    commandVersion,
+    replicaId,
+    replicaCounter,
+    previousLocalTransactionId,
+    observedHeadSequence,
+    commandBytes,
+    intentBytes
+  };
+  if (modality === "spreadsheet") {
+    const causalBase = reader.frontier();
+    const selectiveUndoTargets = decodeSortedIdentifiers(
+      reader,
+      reader.u32(),
+      "pending.selectiveUndoTargets"
+    );
+    return Object.freeze({
+      ...common,
+      modality,
+      causalBase,
+      selectiveUndoTargets,
+      createdAt: nonNegativeSafeInteger2(reader.safeUint(), "pending.createdAt")
+    });
+  }
+  const observedNativeRevision = nonNegativeSafeInteger2(
+    reader.safeUint(),
+    "pending.observedNativeRevision"
+  );
+  return Object.freeze({
+    ...common,
+    modality,
+    observedNativeRevision,
+    createdAt: nonNegativeSafeInteger2(reader.safeUint(), "pending.createdAt")
+  });
+}
+function encodeAuthorPendingFields(writer, input) {
+  writer.u8(modalityTag(input.modality)).u32(positiveSafeInteger2(input.protocolVersion, "author.protocolVersion")).string(requireVersion(input.kernelVersion, "author.kernelVersion"), MAX_VERSION_BYTES).u32(positiveSafeInteger2(input.modelSchemaVersion, "author.modelSchemaVersion")).u32(positiveSafeInteger2(input.commandVersion, "author.commandVersion")).string(requireIdentifier(input.artifactId, "author.artifactId"), MAX_ID_BYTES).string(
+    requireIdentifier(input.clientTransactionId, "author.clientTransactionId"),
+    MAX_ID_BYTES
+  ).string(requireReplicaId(input.replicaId, "author.replicaId"), 16).safeUint(positiveSafeInteger2(input.replicaCounter, "author.replicaCounter")).optionalString(
+    input.previousLocalTransactionId === null ? null : requireIdentifier(input.previousLocalTransactionId, "author.previousLocalTransactionId"),
+    MAX_ID_BYTES
+  ).safeUint(nonNegativeSafeInteger2(input.observedHeadSequence, "author.observedHeadSequence"));
+  if (input.modality === "spreadsheet") {
+    const causalBase = input.causalBase ?? [];
+    const selectiveUndoTargets = input.selectiveUndoTargets ?? [];
+    writer.frontier(causalBase).u32(selectiveUndoTargets.length);
+    encodeSortedIdentifiers(writer, selectiveUndoTargets, "author.selectiveUndoTargets");
+  }
+  writer.safeUint(input.commandBytes.byteLength);
+  writer.safeUint(nonNegativeSafeInteger2(input.createdAt, "author.createdAt"));
+}
+function decodeAuthorPendingFields(reader, commandBytes) {
+  const modality = decodeModality(reader.u8());
+  const value = {
+    modality,
+    protocolVersion: positiveSafeInteger2(reader.u32(), "author.protocolVersion"),
+    kernelVersion: requireVersion(reader.string(MAX_VERSION_BYTES), "author.kernelVersion"),
+    modelSchemaVersion: positiveSafeInteger2(reader.u32(), "author.modelSchemaVersion"),
+    commandVersion: positiveSafeInteger2(reader.u32(), "author.commandVersion"),
+    artifactId: requireIdentifier(reader.string(MAX_ID_BYTES), "author.artifactId"),
+    clientTransactionId: requireIdentifier(
+      reader.string(MAX_ID_BYTES),
+      "author.clientTransactionId"
+    ),
+    replicaId: requireReplicaId(reader.string(16), "author.replicaId"),
+    replicaCounter: positiveSafeInteger2(reader.safeUint(), "author.replicaCounter"),
+    previousLocalTransactionId: optionalIdentifier(
+      reader.optionalString(MAX_ID_BYTES),
+      "author.previousLocalTransactionId"
+    ),
+    observedHeadSequence: nonNegativeSafeInteger2(reader.safeUint(), "author.observedHeadSequence"),
+    ...modality === "spreadsheet" ? {
+      causalBase: reader.frontier(),
+      selectiveUndoTargets: decodeSortedIdentifiers(
+        reader,
+        reader.u32(),
+        "author.selectiveUndoTargets"
+      )
+    } : {},
+    commandBytes,
+    createdAt: 0
+  };
+  const declaredCommandBytes = reader.safeUint();
+  if (declaredCommandBytes !== commandBytes.byteLength) {
+    throw wireError("invalid_segment", "author command length does not match its segment");
+  }
+  value.createdAt = nonNegativeSafeInteger2(reader.safeUint(), "author.createdAt");
+  return Object.freeze(value);
+}
+function requireUrl(value, label) {
+  const bounded = requireBoundedString(value, label, MAX_URL_BYTES);
+  let url;
+  try {
+    url = new URL(bounded);
+  } catch (error) {
+    throw wireError("invalid_url", `${label} must be an absolute URL`, error);
+  }
+  if (!(/* @__PURE__ */ new Set(["https:", "http:", "file:"])).has(url.protocol)) {
+    throw wireError("invalid_url", `${label} uses an unsupported URL scheme`);
+  }
+  if (url.username || url.password || url.hash) {
+    throw wireError("invalid_url", `${label} must not contain credentials or a fragment`);
+  }
+  url.username = "";
+  url.password = "";
+  if (url.href !== bounded) {
+    throw wireError("noncanonical", `${label} must be a canonical URL without credentials`);
+  }
+  return bounded;
+}
+function requireIdentifier(value, label) {
+  const bounded = requireBoundedString(value, label, MAX_ID_BYTES);
+  if (/\p{Cc}/u.test(bounded))
+    throw wireError("invalid_identifier", `${label} contains control characters`);
+  return bounded;
+}
+function requireVersion(value, label) {
+  const bounded = requireBoundedString(value, label, MAX_VERSION_BYTES);
+  if (/\p{Cc}/u.test(bounded))
+    throw wireError("invalid_identifier", `${label} contains control characters`);
+  return bounded;
+}
+function optionalIdentifier(value, label) {
+  return value === null ? null : requireIdentifier(value, label);
+}
+function requireReplicaId(value, label) {
+  if (!/^(?!0{16}$)[0-9a-f]{16}$/.test(value)) {
+    throw wireError(
+      "invalid_identifier",
+      `${label} must be 16 lowercase nonzero hexadecimal digits`
+    );
+  }
+  return value;
+}
+function requireSha256(value, label) {
+  if (!SHA256_PATTERN.test(value))
+    throw wireError("invalid_hash", `${label} must be 64 lowercase hex characters`);
+  return value;
+}
+function requireErrorCode(value) {
+  if (!/^[a-z][a-z0-9_]{0,127}$/.test(value))
+    throw wireError("invalid_error", "invalid worker error code");
+  return value;
+}
+function requireBoundedString(value, label, maximumBytes) {
+  if (typeof value !== "string" || value.length === 0)
+    throw wireError("invalid_string", `${label} is empty`);
+  if (new TextEncoder().encode(value).byteLength > maximumBytes) {
+    throw wireError("string_too_large", `${label} exceeds its byte limit`);
+  }
+  return value;
+}
+function positiveSafeInteger2(value, label) {
+  if (!Number.isSafeInteger(value) || value <= 0)
+    throw wireError("invalid_number", `${label} must be positive`);
+  return value;
+}
+function nonNegativeSafeInteger2(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw wireError("invalid_number", `${label} must be a non-negative safe integer`);
+  }
+  return value;
+}
+function decodeBoolean(value, label) {
+  if (value === 0) return false;
+  if (value === 1) return true;
+  throw wireError("noncanonical", `${label} has an invalid boolean tag`);
+}
+function encodeSortedIdentifiers(writer, values, label) {
+  if (!Array.isArray(values) || values.length > 1e4) {
+    throw wireError("invalid_identifiers", `${label} exceeds its item limit`);
+  }
+  let previous = "";
+  for (let index = 0; index < values.length; index += 1) {
+    const value = requireIdentifier(values[index], `${label}[${index}]`);
+    if (index > 0 && previous >= value) {
+      throw wireError("noncanonical", `${label} must be unique and code-unit sorted`);
+    }
+    writer.string(value, MAX_ID_BYTES);
+    previous = value;
+  }
+}
+function decodeSortedIdentifiers(reader, count, label) {
+  if (count > 1e4) throw wireError("invalid_identifiers", `${label} exceeds its item limit`);
+  const values = [];
+  let previous = "";
+  for (let index = 0; index < count; index += 1) {
+    const value = requireIdentifier(reader.string(MAX_ID_BYTES), `${label}[${index}]`);
+    if (index > 0 && previous >= value) {
+      throw wireError("noncanonical", `${label} must be unique and code-unit sorted`);
+    }
+    values.push(value);
+    previous = value;
+  }
+  return Object.freeze(values);
+}
+function wireError(code, message, cause) {
+  return new ArtifactWorkerProtocolError(
+    code,
+    message,
+    cause === void 0 ? void 0 : { cause }
+  );
+}
+function validateInitializeLimits(input) {
+  requireVersion(input.kernelVersion, "kernelVersion");
+  for (const [value, label] of [
+    [input.protocolVersion, "protocolVersion"],
+    [input.modelSchemaVersion, "modelSchemaVersion"],
+    [input.commandVersion, "commandVersion"]
+  ]) {
+    positiveSafeInteger2(value, label);
+    if (value > 65535) throw wireError("invalid_version", `${label} exceeds uint16`);
+  }
+  const limits = [
+    [input.maximumSnapshotBytes, HARD_MAX_SNAPSHOT_BYTES, "maximumSnapshotBytes"],
+    [input.maximumCommandBytes, HARD_MAX_COMMAND_BYTES, "maximumCommandBytes"],
+    [input.maximumIntentBytes, HARD_MAX_INTENT_BYTES, "maximumIntentBytes"],
+    [
+      input.maximumCommittedTransactionBytes,
+      HARD_MAX_COMMITTED_TRANSACTION_BYTES,
+      "maximumCommittedTransactionBytes"
+    ],
+    [input.maximumQueryBytes, HARD_MAX_QUERY_BYTES, "maximumQueryBytes"],
+    [input.maximumQueryResponseBytes, HARD_MAX_QUERY_RESPONSE_BYTES, "maximumQueryResponseBytes"],
+    [input.maximumPendingTransactions, HARD_MAX_PENDING_TRANSACTIONS, "maximumPendingTransactions"]
+  ];
+  for (const [value, maximum, label] of limits) {
+    positiveSafeInteger2(value, label);
+    if (value > maximum)
+      throw wireError("invalid_limit", `${label} exceeds the hard safety ceiling`);
+  }
+}
+
+export {
+  DEFAULT_ARTIFACT_WORKER_RPC_LIMITS,
+  ArtifactWorkerProtocolError,
+  encodeArtifactWorkerRpcMessage,
+  decodeArtifactWorkerRpcMessage,
+  transferListForArtifactWorkerRpcMessage,
+  ownedTransferBuffer,
+  encodeInitialize,
+  decodeInitialize,
+  encodeSnapshotMetadata,
+  decodeSnapshotMetadata,
+  encodeCommittedMetadata,
+  decodeCommittedMetadata,
+  encodePendingListMetadata,
+  decodePendingListMetadata,
+  encodeReconcileMetadata,
+  decodeReconcileMetadata,
+  encodeAuthorPendingMetadata,
+  decodeAuthorPendingMetadata,
+  encodeStateResponse,
+  decodeStateResponse,
+  encodeProjectionResponse,
+  decodeProjectionResponse,
+  encodeErrorPayload,
+  decodeErrorPayload,
+  sha256Hex,
+  requireMatchingHash
+};
+//# sourceMappingURL=chunk-VWE2QIVO.js.map