@stream-mdx/protocol 0.4.0 → 1.0.0

package/CHANGELOG.md

@@ -1,4 +1,100 @@
 # Changelog
 
+## 1.0.0
+
+### Major Changes
+
+- 159a237: Use source-owned records for root code fences, tables, and paragraphs, with bounded line, row, and span updates and on-demand full-source reads. Patch consumers must accept wire protocol 2.0, replace `appendLines` with `appendCode`, adopt `appendParagraph` and `updateParagraphSpans`, and handle native table operations; the retired operation has no compatibility alias. Plugins must use the source snapshot and on-demand `readBlocks` document context instead of a retained `blocks` array.
+
+  Live consumers now initialize one canonical root input document from the
+  `INITIALIZED` snapshot baseline and retain later admitted bytes with ordered
+  semantic `appendInputSource` root patches. Missing live baselines are
+  incompatible; cold `Block[]` and standalone snapshots keep only their honest
+  per-block source slices. Native code, table, and paragraph windows share the
+  consumer input document while retaining independent owner generations and
+  exact newly owned `sourceAppend` suffixes. Empty baselines are valid, and static
+  artifact version 1 is unchanged.
+
+  Preserve owner identity and retirement guards when replacing active snapshots. Reject regressing revisions and source frontiers, while allowing valid source-stable table and paragraph dependency meaning updates after finalization. Same-generation finalized source cannot grow or reopen. Keep final code highlighting and fallback presentation intact without retransmitting source in presentation-only patches.
+
+  For paragraph owners after raw Markdown EOF, reopen only the actual trailing paragraph under a fresh owner generation. Do not fuse intervening definition or root source into an earlier paragraph. Keep genuinely unowned provisional following roots eligible for continuation.
+
+  Do not re-finalize completed paragraph owners when later roots extend the shared input. Preserve their original parser frontier and captured source while still publishing valid late dependency changes.
+
+  Queue imperative append and finalize calls behind their matching initialization acknowledgement. Ignore errors from detached or superseded initializations without changing public worker attachment readiness, and keep detached snapshot callbacks callable.
+
+  Render managed paragraph children through the native span view while preserving registered source props and finalized block overrides. Default appends avoid global block/MDX scans; legacy full-source custom props use an explicit cold projection. Cold Block exports also retain admitted open native tables.
+
+  Blocks whose rendering depends on HTML stay on the base HTML grouping path. Genuine inline-HTML paragraphs and HTML-bearing containers retire native owners instead of adopting or rehoming them; tail-local auto-close and native ownership for non-HTML blocks remain.
+
+- Release the coordinated 1.0.0 package line. Upgrade all installed StreamMDX packages together and recopy the hosted worker from the matching version. Internal runtime dependencies remain exact versions; the optional unified adapter's StreamMDX peers require the 1.x line.
+
+  Migration from 0.5.0:
+
+  - Remove imports of `@stream-mdx/plugins/registry`, `/base`, and `/math`, their `stream-mdx/plugins/*` convenience re-exports, and `@stream-mdx/worker/streaming/custom-matcher`. `PluginRegistry`, `globalPluginRegistry`, legacy match handlers, and legacy math plugin factories are no longer public. Use native Lezer extensions, serializable `SyntaxRuleSpec` rules, and per-engine `DocumentPluginRegistry` document plugins. Native extension functions belong in the engine or custom worker bundle, not in structured-clone `INIT` messages.
+  - `MarkdownEngine` owns its parser, queue, document state, plugins, and caches. Construct it with `{ post, extensions? }`, send configuration and document resets through `handle({ type: "INIT", ... })`, and call terminal `dispose()` when finished. Use public `serveMarkdownWorker` and `createInlineEngineWorker` factories instead of old global runtime plumbing. Worker URLs and actual Worker factories create renderer-owned workers that terminate on detach; an existing Worker is caller-owned. Caller-created inline adapters also need caller-owned termination. See `docs/PUBLIC_API.md` and `docs/PLUGIN_ABI.md` for supported wiring.
+    `managedWorker={true}` requires a supplied Worker instance or caller-accessible factory and caller-owned initialization/document commands. URL/default workers and `engine="main-thread"` are rejected, even with a supplied worker source. Managed auto cannot silently fall back inline. Borrowed instances remain caller-owned; factory-created workers remain component-owned and terminate on detach.
+  - Provisional lookahead inputs over 512 characters now return raw text before completeness scanning, including closed strings. Oversized finalized/nonprovisional complete content is preserved; within-budget finalized projection retains its behavior. Internal defaults are `maxScanChars: 512`, `maxNewlines: 2`, `maxSyntheticOps: 6`, `maxNestingDepth: 8`, `maxValidationFailures: 1`, and `maxProviderMs: 5`. Provider timers start before scanning; these caps are not React props or latency guarantees.
+  - Core root exports no longer expose Lezer converter, math extension factory, link-label normalization, entity decoder, or default/regex plugin adapter internals. Use retained parser/preparation APIs and public worker/compiler entries. Owning parser settings remain authoritative, including disabled math in nested snapshot fallbacks.
+  - `ComponentRegistry` treats a block component as custom only when it differs from the built-in default. Custom paragraph and quote wrappers must render the supplied `children` projection to retain native inline, HTML, and nested-block ownership. Do not reconstruct those children from raw source.
+  - `CodeFenceRendererProps.renderCode` is a React node, not a callback. Return it directly as a fallback. `language`, fence metadata, and emitted `language-*` classes preserve the authored info word, such as `js`, rather than the canonical Shiki grammar name. Renderer lookups still fall back to canonical names and accept aliases. Unlabeled and indented code has no language class or `data-language` attribute.
+  - `restart()` cancels the current async iterator generation; it does not replay a consumed iterator. Supply a fresh iterator for a new stream. Renderer-owned text replacements reset the engine document, while caller-initialized managed workers retain their document ownership.
+  - URL transformation and HTML/style sanitization now apply across native client rendering, SSR, and the optional unified adapter. Rejected URLs are omitted; custom components must honor the supplied sanitized attributes and children. `allowedElements` and `disallowedElements` are mutually exclusive.
+
+  The remaining consumed changesets describe the new opt-in renderers, controls, animation, table virtualization, themes, native extension APIs, and correctness/security fixes. These features do not enable themselves when upgrading. See the root README migration section and the generated package changelogs before upgrading custom integrations.
+
+### Patch Changes
+
+- 3f24715: Bound host-accepted and in-flight source with generation-tagged worker admission acknowledgements. Imperative append accepts a whole UTF-16 chunk or refuses it without partial admission; automatic iterators losslessly split larger chunks and wait for capacity.
+
+  Finalization seals the host generation immediately and resolves one shared promise after all earlier accepted source reaches the matching native finalization and semantic store barrier. Reset invalidates pending capacity/finalization waits, including automatic source replacement on a reused renderer. The barrier does not imply a React commit or optional enrichment readiness.
+
+  Cache inline regex eligibility per immutable parser context, rather than rescanning the whole context at each token position. A later marker-bearing context still performs its own check, and weak keys do not retain completed contexts.
+
+  Demo automation now observes synchronous source and completion state immediately after fast-forward or finalization, and restart opens a fresh wrapper session before replacing its worker.
+
+- 3f24715: Require each live worker PATCH and every schema-2 protocol event to carry its native root document generation. Renderers and TUI event stores reject stale-generation work against the current validated INITIALIZED baseline, including after queueing; TUI replacement also clears old transaction/status metadata. Caller-managed worker attachment stays pending until an observed baseline, then drains accepted input once. Node and direct snapshot compilers bind patch/finalization handling to that baseline. Static snapshot artifacts remain version 1.
+
+  Explicit cold TUI replacement retires the old native lease, so delayed snapshots and lifecycle events cannot reclaim the replacement. A validated newer same-stream baseline can resume delivery.
+
+  Bind same-turn restart capacity waits to the new session's admitting renderer, retaining their requested capacity and cancellation options without dropping accepted source.
+
+  Use the task-packed protocol dependency in installed Node, Next, and Vite smoke consumers instead of allowing a registry fallback.
+
+  Generate JavaScript for both installed runtime loaders and replay a replacement root's actual finalization patches before checking completed source.
+
+  Render the terminal example from authored cold block source without adding duplicate heading, quote, or code-fence markers.
+
+- Updated dependencies [1669abb]
+- Updated dependencies [0e96940]
+- Updated dependencies [5833985]
+- Updated dependencies [9c482bd]
+- Updated dependencies [150a0ac]
+- Updated dependencies [7879ed5]
+- Updated dependencies [73bdb36]
+- Updated dependencies [fdaa309]
+- Updated dependencies [e02e7cf]
+- Updated dependencies
+  - @stream-mdx/core@1.0.0
+
+## 0.5.0
+
+### Minor Changes
+
+- Promote the current hardening and product-surface tranche as `0.5.0`.
+
+  This release rolls up:
+
+  - renderer/store correctness hardening
+  - seeded smoke and scheduler-parity release discipline
+  - benchmark methodology and comparison cleanup
+  - docs, showcase, and TUI/product surface maturation
+
+### Patch Changes
+
+- Updated dependencies
+  - @stream-mdx/core@0.5.0
+
 ## 0.1.1
+
 - Initial protocol types and event envelope for StreamMDX Protocol v1.

package/README.md

@@ -1,13 +1,13 @@
-# @stream-mdx/protocol
+# `@stream-mdx/protocol`
 
-Protocol types for StreamMDX JSON/object streaming.
+`@stream-mdx/protocol` defines the transport-facing protocol types for structured StreamMDX event/object streaming. It is intended for consumers that need a stable, typed contract outside the React/browser UI layer.
 
-This package defines the event envelope, capability metadata, and token
-structures used by StreamMDX Protocol v1. It is intended for consumers that
-need a stable, versioned contract (e.g., terminal UIs).
+Typical consumers include:
 
-Most web-only consumers do not need this package directly. Start with `stream-mdx`
-or `@stream-mdx/react` for the React renderer.
+- TUIs and CLI tools
+- NDJSON transports
+- service boundaries that want typed event envelopes
+- debugging or replay tooling that records and replays structured patch streams
 
 ## Install
 
@@ -15,21 +15,28 @@ or `@stream-mdx/react` for the React renderer.
 npm install @stream-mdx/protocol
 ```
 
-## What this provides
+## What This Package Provides
 
-- Shared protocol types for streaming events and capability negotiation.
-- Token / block payload shapes intended for structured-clone-safe transport.
+| Surface | Purpose |
+| --- | --- |
+| Event envelope types | Transport-safe event/message contracts |
+| Capability metadata | Describe supported features or modes |
+| Token/block payload types | Structured-clone-safe payload shapes |
 
-## Typical usage (TUI/CLI)
+## Typical Pairings
 
-Pair it with `@stream-mdx/tui` for NDJSON helpers + a lightweight snapshot store:
+| Pair with | Why |
+| --- | --- |
+| [`@stream-mdx/tui`](../markdown-v2-tui/README.md) | NDJSON helpers and snapshot store |
+| [`@stream-mdx/core`](../markdown-v2-core/README.md) | Shared low-level types and helpers |
+| [`@stream-mdx/worker`](../markdown-v2-worker/README.md) | Worker-side generation/consumption paths |
 
-```bash
-npm install @stream-mdx/tui @stream-mdx/protocol @stream-mdx/core
-```
-
-## Docs
+## Documentation
 
-- Public API: https://github.com/kmccleary3301/stream-mdx/blob/main/docs/PUBLIC_API.md
-- CLI usage: https://github.com/kmccleary3301/stream-mdx/blob/main/docs/CLI_USAGE.md
-- Protocol spec: https://github.com/kmccleary3301/stream-mdx/blob/main/docs/STREAMMDX_JSON_DIFF_SPEC.md
+- Start from the runnable example path with `npm run example:tui-minimal` from the repo root.
+- [`../../examples/tui-minimal/README.md`](../../examples/tui-minimal/README.md)
+- [`../../docs/TUI_MINIMAL_EXAMPLE.md`](../../docs/TUI_MINIMAL_EXAMPLE.md)
+- [`../../docs/TUI_GUIDE.md`](../../docs/TUI_GUIDE.md)
+- [`../../docs/STREAMMDX_JSON_DIFF_SPEC.md`](../../docs/STREAMMDX_JSON_DIFF_SPEC.md)
+- [`../../docs/CLI_USAGE.md`](../../docs/CLI_USAGE.md)
+- [`../../docs/PUBLIC_API.md`](../../docs/PUBLIC_API.md)

package/dist/index.cjs

@@ -21,13 +21,40 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   STREAM_MDX_PROTOCOL_ID: () => STREAM_MDX_PROTOCOL_ID,
-  STREAM_MDX_SCHEMA_VERSION: () => STREAM_MDX_SCHEMA_VERSION
+  STREAM_MDX_SCHEMA_VERSION: () => import_core.STREAM_MDX_SCHEMA_VERSION,
+  SourceCapacityError: () => SourceCapacityError,
+  StreamSessionError: () => StreamSessionError
 });
 module.exports = __toCommonJS(index_exports);
+var import_core = require("@stream-mdx/core");
+
+// src/stream-admission.ts
+var SourceCapacityError = class extends Error {
+  constructor(offeredSourceUnits, pendingSourceUnits, hardLimitSourceUnits) {
+    super(
+      `Appending ${offeredSourceUnits} UTF-16 source units would exceed the ${hardLimitSourceUnits}-unit admission limit (${pendingSourceUnits} units are pending)`
+    );
+    this.name = "SourceCapacityError";
+    this.offeredSourceUnits = offeredSourceUnits;
+    this.pendingSourceUnits = pendingSourceUnits;
+    this.hardLimitSourceUnits = hardLimitSourceUnits;
+    this.retryable = offeredSourceUnits <= hardLimitSourceUnits;
+  }
+};
+var StreamSessionError = class extends Error {
+  constructor(reason, message) {
+    super(message);
+    this.name = "StreamSessionError";
+    this.reason = reason;
+  }
+};
+
+// src/index.ts
 var STREAM_MDX_PROTOCOL_ID = "streammdx";
-var STREAM_MDX_SCHEMA_VERSION = "1.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   STREAM_MDX_PROTOCOL_ID,
-  STREAM_MDX_SCHEMA_VERSION
+  STREAM_MDX_SCHEMA_VERSION,
+  SourceCapacityError,
+  StreamSessionError
 });

package/dist/index.d.cts

@@ -1,8 +1,41 @@
-import { Block, Patch, PatchMetrics } from '@stream-mdx/core';
-export { DiffBlock, DiffKind, DiffLine, DiffLineKind, ThemedLine, ThemedToken, TokenLineV1, TokenSpan, TokenStyle } from '@stream-mdx/core';
+import { STREAM_MDX_SCHEMA_VERSION, NodeSnapshot, Patch, PatchMetrics } from '@stream-mdx/core';
+export { DiffBlock, DiffKind, DiffLine, DiffLineKind, STREAM_MDX_SCHEMA_VERSION, ThemedLine, ThemedToken, TokenLineV1, TokenSpan, TokenStyle } from '@stream-mdx/core';
+
+type AppendResult = {
+    /** Total UTF-16 source units accepted by append calls in this session. */
+    acceptedSourceUnits: number;
+    /** Accepted append units not yet acknowledged by the worker. */
+    pendingSourceUnits: number;
+    /** Whether the soft admission threshold has been reached. */
+    shouldPause: boolean;
+};
+type FinalizeResult = {
+    /** Native worker document generation that finalized this host session. */
+    generation: number;
+    /** Total UTF-16 source units accepted by append calls in this session. */
+    acceptedSourceUnits: number;
+    /** Accepted source units whose semantic patches have committed to the renderer store. */
+    committedSourceUnits: number;
+};
+type WaitForCapacityOptions = {
+    /** UTF-16 source units the next append needs to admit. */
+    units: number;
+    signal?: AbortSignal;
+};
+type StreamSessionErrorReason = "sealed" | "stale-generation" | "disposed";
+declare class SourceCapacityError extends Error {
+    readonly offeredSourceUnits: number;
+    readonly pendingSourceUnits: number;
+    readonly hardLimitSourceUnits: number;
+    readonly retryable: boolean;
+    constructor(offeredSourceUnits: number, pendingSourceUnits: number, hardLimitSourceUnits: number);
+}
+declare class StreamSessionError extends Error {
+    readonly reason: StreamSessionErrorReason;
+    constructor(reason: StreamSessionErrorReason, message: string);
+}
 
 declare const STREAM_MDX_PROTOCOL_ID = "streammdx";
-declare const STREAM_MDX_SCHEMA_VERSION = "1.0";
 type StreamMdxEventType = "init" | "snapshot" | "patch" | "metrics" | "error" | "done";
 type StreamMdxCapabilityLevel = "none" | "v1";
 type StreamMdxCapabilities = {
@@ -24,41 +57,42 @@ type StreamMdxEventBase = {
     protocol: typeof STREAM_MDX_PROTOCOL_ID;
     schemaVersion: typeof STREAM_MDX_SCHEMA_VERSION;
     streamId: string;
+    generation: number;
     event: StreamMdxEventType;
     tx?: number;
 };
-type StreamMdxInitEventV1 = StreamMdxEventBase & {
+type StreamMdxInitEvent = StreamMdxEventBase & {
     event: "init";
     createdAt?: number;
     capabilities?: StreamMdxCapabilities;
     theme?: StreamMdxTheme;
     shikiVersion?: string;
 };
-type StreamMdxSnapshotEventV1 = StreamMdxEventBase & {
+type StreamMdxSnapshotEvent = StreamMdxEventBase & {
     event: "snapshot";
-    blocks: Block[];
+    snapshot: NodeSnapshot;
 };
-type StreamMdxPatchEventV1 = StreamMdxEventBase & {
+type StreamMdxPatchEvent = StreamMdxEventBase & {
     event: "patch";
     tx: number;
     patches: Patch[];
     metrics?: PatchMetrics | null;
 };
-type StreamMdxMetricsEventV1 = StreamMdxEventBase & {
+type StreamMdxMetricsEvent = StreamMdxEventBase & {
     event: "metrics";
     tx?: number;
     metrics: PatchMetrics;
 };
-type StreamMdxErrorEventV1 = StreamMdxEventBase & {
+type StreamMdxErrorEvent = StreamMdxEventBase & {
     event: "error";
     message: string;
     stack?: string;
 };
-type StreamMdxDoneEventV1 = StreamMdxEventBase & {
+type StreamMdxDoneEvent = StreamMdxEventBase & {
     event: "done";
     finalTx?: number;
     status: "ok" | "error";
 };
-type StreamMdxEventV1 = StreamMdxInitEventV1 | StreamMdxSnapshotEventV1 | StreamMdxPatchEventV1 | StreamMdxMetricsEventV1 | StreamMdxErrorEventV1 | StreamMdxDoneEventV1;
+type StreamMdxEvent = StreamMdxInitEvent | StreamMdxSnapshotEvent | StreamMdxPatchEvent | StreamMdxMetricsEvent | StreamMdxErrorEvent | StreamMdxDoneEvent;
 
-export { STREAM_MDX_PROTOCOL_ID, STREAM_MDX_SCHEMA_VERSION, type StreamMdxCapabilities, type StreamMdxCapabilityLevel, type StreamMdxDoneEventV1, type StreamMdxErrorEventV1, type StreamMdxEventBase, type StreamMdxEventType, type StreamMdxEventV1, type StreamMdxInitEventV1, type StreamMdxMetricsEventV1, type StreamMdxPatchEventV1, type StreamMdxSnapshotEventV1, type StreamMdxTheme };
+export { type AppendResult, type FinalizeResult, STREAM_MDX_PROTOCOL_ID, SourceCapacityError, type StreamMdxCapabilities, type StreamMdxCapabilityLevel, type StreamMdxDoneEvent, type StreamMdxErrorEvent, type StreamMdxEvent, type StreamMdxEventBase, type StreamMdxEventType, type StreamMdxInitEvent, type StreamMdxMetricsEvent, type StreamMdxPatchEvent, type StreamMdxSnapshotEvent, type StreamMdxTheme, StreamSessionError, type StreamSessionErrorReason, type WaitForCapacityOptions };

package/dist/index.d.ts

@@ -1,8 +1,41 @@
-import { Block, Patch, PatchMetrics } from '@stream-mdx/core';
-export { DiffBlock, DiffKind, DiffLine, DiffLineKind, ThemedLine, ThemedToken, TokenLineV1, TokenSpan, TokenStyle } from '@stream-mdx/core';
+import { STREAM_MDX_SCHEMA_VERSION, NodeSnapshot, Patch, PatchMetrics } from '@stream-mdx/core';
+export { DiffBlock, DiffKind, DiffLine, DiffLineKind, STREAM_MDX_SCHEMA_VERSION, ThemedLine, ThemedToken, TokenLineV1, TokenSpan, TokenStyle } from '@stream-mdx/core';
+
+type AppendResult = {
+    /** Total UTF-16 source units accepted by append calls in this session. */
+    acceptedSourceUnits: number;
+    /** Accepted append units not yet acknowledged by the worker. */
+    pendingSourceUnits: number;
+    /** Whether the soft admission threshold has been reached. */
+    shouldPause: boolean;
+};
+type FinalizeResult = {
+    /** Native worker document generation that finalized this host session. */
+    generation: number;
+    /** Total UTF-16 source units accepted by append calls in this session. */
+    acceptedSourceUnits: number;
+    /** Accepted source units whose semantic patches have committed to the renderer store. */
+    committedSourceUnits: number;
+};
+type WaitForCapacityOptions = {
+    /** UTF-16 source units the next append needs to admit. */
+    units: number;
+    signal?: AbortSignal;
+};
+type StreamSessionErrorReason = "sealed" | "stale-generation" | "disposed";
+declare class SourceCapacityError extends Error {
+    readonly offeredSourceUnits: number;
+    readonly pendingSourceUnits: number;
+    readonly hardLimitSourceUnits: number;
+    readonly retryable: boolean;
+    constructor(offeredSourceUnits: number, pendingSourceUnits: number, hardLimitSourceUnits: number);
+}
+declare class StreamSessionError extends Error {
+    readonly reason: StreamSessionErrorReason;
+    constructor(reason: StreamSessionErrorReason, message: string);
+}
 
 declare const STREAM_MDX_PROTOCOL_ID = "streammdx";
-declare const STREAM_MDX_SCHEMA_VERSION = "1.0";
 type StreamMdxEventType = "init" | "snapshot" | "patch" | "metrics" | "error" | "done";
 type StreamMdxCapabilityLevel = "none" | "v1";
 type StreamMdxCapabilities = {
@@ -24,41 +57,42 @@ type StreamMdxEventBase = {
     protocol: typeof STREAM_MDX_PROTOCOL_ID;
     schemaVersion: typeof STREAM_MDX_SCHEMA_VERSION;
     streamId: string;
+    generation: number;
     event: StreamMdxEventType;
     tx?: number;
 };
-type StreamMdxInitEventV1 = StreamMdxEventBase & {
+type StreamMdxInitEvent = StreamMdxEventBase & {
     event: "init";
     createdAt?: number;
     capabilities?: StreamMdxCapabilities;
     theme?: StreamMdxTheme;
     shikiVersion?: string;
 };
-type StreamMdxSnapshotEventV1 = StreamMdxEventBase & {
+type StreamMdxSnapshotEvent = StreamMdxEventBase & {
     event: "snapshot";
-    blocks: Block[];
+    snapshot: NodeSnapshot;
 };
-type StreamMdxPatchEventV1 = StreamMdxEventBase & {
+type StreamMdxPatchEvent = StreamMdxEventBase & {
     event: "patch";
     tx: number;
     patches: Patch[];
     metrics?: PatchMetrics | null;
 };
-type StreamMdxMetricsEventV1 = StreamMdxEventBase & {
+type StreamMdxMetricsEvent = StreamMdxEventBase & {
     event: "metrics";
     tx?: number;
     metrics: PatchMetrics;
 };
-type StreamMdxErrorEventV1 = StreamMdxEventBase & {
+type StreamMdxErrorEvent = StreamMdxEventBase & {
     event: "error";
     message: string;
     stack?: string;
 };
-type StreamMdxDoneEventV1 = StreamMdxEventBase & {
+type StreamMdxDoneEvent = StreamMdxEventBase & {
     event: "done";
     finalTx?: number;
     status: "ok" | "error";
 };
-type StreamMdxEventV1 = StreamMdxInitEventV1 | StreamMdxSnapshotEventV1 | StreamMdxPatchEventV1 | StreamMdxMetricsEventV1 | StreamMdxErrorEventV1 | StreamMdxDoneEventV1;
+type StreamMdxEvent = StreamMdxInitEvent | StreamMdxSnapshotEvent | StreamMdxPatchEvent | StreamMdxMetricsEvent | StreamMdxErrorEvent | StreamMdxDoneEvent;
 
-export { STREAM_MDX_PROTOCOL_ID, STREAM_MDX_SCHEMA_VERSION, type StreamMdxCapabilities, type StreamMdxCapabilityLevel, type StreamMdxDoneEventV1, type StreamMdxErrorEventV1, type StreamMdxEventBase, type StreamMdxEventType, type StreamMdxEventV1, type StreamMdxInitEventV1, type StreamMdxMetricsEventV1, type StreamMdxPatchEventV1, type StreamMdxSnapshotEventV1, type StreamMdxTheme };
+export { type AppendResult, type FinalizeResult, STREAM_MDX_PROTOCOL_ID, SourceCapacityError, type StreamMdxCapabilities, type StreamMdxCapabilityLevel, type StreamMdxDoneEvent, type StreamMdxErrorEvent, type StreamMdxEvent, type StreamMdxEventBase, type StreamMdxEventType, type StreamMdxInitEvent, type StreamMdxMetricsEvent, type StreamMdxPatchEvent, type StreamMdxSnapshotEvent, type StreamMdxTheme, StreamSessionError, type StreamSessionErrorReason, type WaitForCapacityOptions };

package/dist/index.mjs

@@ -1,7 +1,32 @@
+// src/index.ts
+import { STREAM_MDX_SCHEMA_VERSION } from "@stream-mdx/core";
+
+// src/stream-admission.ts
+var SourceCapacityError = class extends Error {
+  constructor(offeredSourceUnits, pendingSourceUnits, hardLimitSourceUnits) {
+    super(
+      `Appending ${offeredSourceUnits} UTF-16 source units would exceed the ${hardLimitSourceUnits}-unit admission limit (${pendingSourceUnits} units are pending)`
+    );
+    this.name = "SourceCapacityError";
+    this.offeredSourceUnits = offeredSourceUnits;
+    this.pendingSourceUnits = pendingSourceUnits;
+    this.hardLimitSourceUnits = hardLimitSourceUnits;
+    this.retryable = offeredSourceUnits <= hardLimitSourceUnits;
+  }
+};
+var StreamSessionError = class extends Error {
+  constructor(reason, message) {
+    super(message);
+    this.name = "StreamSessionError";
+    this.reason = reason;
+  }
+};
+
 // src/index.ts
 var STREAM_MDX_PROTOCOL_ID = "streammdx";
-var STREAM_MDX_SCHEMA_VERSION = "1.0";
 export {
   STREAM_MDX_PROTOCOL_ID,
-  STREAM_MDX_SCHEMA_VERSION
+  STREAM_MDX_SCHEMA_VERSION,
+  SourceCapacityError,
+  StreamSessionError
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-mdx/protocol",
-  "version": "0.4.0",
+  "version": "1.0.0",
   "description": "StreamMDX protocol types and event envelope for JSON/object streaming",
   "license": "MIT",
   "repository": {
@@ -34,6 +34,6 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@stream-mdx/core": "0.4.0"
+    "@stream-mdx/core": "1.0.0"
   }
 }