@async/framework 0.11.15 → 0.11.17

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.11.17 - 2026-06-19
+
+- Added the stream backpatch protocol to `createBoundaryReceiver(...)` with
+  strict `attrs` validation for built numeric triples and no-build named
+  tuples.
+- Added pending-slot replacement and reveal coordination for `as-ready`,
+  `forwards`, `backwards`, and `together` stream groups, including collapsed
+  and hidden tail visibility handling.
+- Added the `AsyncStream` browser helper for no-build JSON stream patches,
+  template replacement, configured `data-async-*` attributes, and direct-child
+  reveal metadata synthesis.
+- Added stream backpatch scenario-size coverage and updated browser scenario
+  budgets for the expanded public stream surface.
+- Bundle size from bundled TypeScript source: `browser.ts` raw 221,403 B (221.4 KB / 0.221 MB), gzip 42,093 B (42.1 KB / 0.042 MB), br 34,797 B (34.8 KB / 0.035 MB) -> `browser.min.js` raw 95,027 B (95.0 KB / 0.095 MB), gzip 28,145 B (28.1 KB / 0.028 MB), br 24,793 B (24.8 KB / 0.025 MB); delta raw -126,376 B (-126.4 KB / -0.126 MB), gzip -13,948 B (-13.9 KB / -0.014 MB), br -10,004 B (-10.0 KB / -0.010 MB).
+
+## 0.11.16 - 2026-06-19
+
+- Added runtime slice entrypoints for `@async/framework/runtime`,
+  `@async/framework/runtime/signals`, and `@async/framework/runtime/events`.
+- Added generated package artifacts and installed-package coverage for runtime
+  slice subpaths.
+- Added deterministic scenario-size fixtures and checks for runtime, router,
+  server-call, and boundary receiver examples.
+- Added package-owned release evidence checks before release ensure so generated
+  release workflows verify bundle and scenario evidence before publishing.
+- Bundle size from bundled TypeScript source: `browser.ts` raw 197,173 B (197.2 KB / 0.197 MB), gzip 37,198 B (37.2 KB / 0.037 MB), br 30,914 B (30.9 KB / 0.031 MB) -> `browser.min.js` raw 84,013 B (84.0 KB / 0.084 MB), gzip 24,894 B (24.9 KB / 0.025 MB), br 22,079 B (22.1 KB / 0.022 MB); delta raw -113,160 B (-113.2 KB / -0.113 MB), gzip -12,304 B (-12.3 KB / -0.012 MB), br -8,835 B (-8.8 KB / -0.009 MB).
+
 ## 0.11.15 - 2026-06-19
 
 - Made the source package private and kept its public surface to the minimal

package/README.md

@@ -43,10 +43,10 @@ Async.start({ root: document });
 
 ## What It Is
 
-`@async/framework` is the Layer 1 runtime plus the first Layer 2 app/server
-primitives. It keeps the runtime small and explicit:
+`@async/framework` is the L1 runtime plus the first L1.5 app/server and
+streaming primitives. It keeps the runtime small and explicit:
 
-- No build step for Layer 1 consumers.
+- No build step for L1 consumers.
 - No virtual DOM, diff path, hydration runtime, or component rerender loop.
 - Signals are the state boundary.
 - `Async.use(...)` registers app declarations before or after startup.
@@ -68,18 +68,14 @@ to the same runtime registries and HTML protocol.
 Async is designed as layers, so each level can stay useful without forcing the
 next level on every app.
 
-| Layer | Name | Requirement | Purpose |
+| Shorthand | Name | Requirement | Purpose |
 | --- | --- | --- | --- |
-| 1 | Runtime bootloader | No build. CDN or direct ESM import. | Signals, async signals, scheduler, handlers, command events, lifecycle pseudo-events, scoped fragments, and boundary swaps. |
-| 2 | App/server layer | Light server integration. No app compiler required. | `Async.use(...)`, router modes, server function proxy, partial registry, SSR output, browser activation, and split browser/server cache. |
-| 3 | Authoring build | Build step required. | JSX, ESM, and TypeScript authoring that lowers into Layer 1 HTML attributes and Layer 2 registries. |
-| 4 | Chunk and resumability metadata | Build metadata required. | Lazy module manifests, visibility/prefetch hints, resource graphs, and resumability records that the bootloader can consume. |
-| 5 | Framework compiler | Compiler required. | Server/client partitioning, code motion, optimized registry generation, serialized closures, and deeper resumability transforms. |
-| 6 | TSRX and intent layer | Higher-level compiler required. | More declarative author intent, AI/compiler-friendly metadata, and source forms that generate lower-layer Async apps. |
-
-The package in this repository intentionally focuses on Layers 1 and 2. Layers
-3 through 6 are higher authoring surfaces, not extra runtime requirements for
-plain HTML apps.
+| L1 | Runtime bootloader | No build. CDN or direct ESM import. | Signals, async signals, scheduler, handlers, command events, lifecycle pseudo-events, scoped fragments, and boundary swaps. |
+| L1.5 | App/server and streaming bridge | Light server integration. No app compiler required. | `Async.use(...)`, router modes, server function proxy, partial registry, SSR output, browser activation, split browser/server cache, and streamed boundary patches. |
+| L2 | Build-required authoring and compiler profile | Build step required. | JSX, ESM, and TypeScript authoring, optimizer reports, generated plans, generated registries, chunks, manifests, and future resumability records that lower onto L1 and L1.5 protocols. |
+
+The package in this repository intentionally focuses on L1 and L1.5. L2 is a
+higher authoring surface, not an extra runtime requirement for plain HTML apps.
 
 ## Install
 

package/browser.d.ts

@@ -513,10 +513,30 @@ export interface LoaderInstance {
 export type AsyncLoaderOptions = LoaderOptions;
 export type AsyncLoaderInstance = LoaderInstance;
 
+export type AttributePatchValue = string | number | boolean | null | undefined;
+export type BuiltAttributePatchTriples = readonly AttributePatchValue[];
+export type NoBuildAttributePatchTuple = readonly [targetName: string, attrName: string, value: AttributePatchValue];
+export type NoBuildAttributePatchTuples = readonly NoBuildAttributePatchTuple[];
+export interface StreamReplacement {
+  target: string;
+  html?: TemplateLike;
+  template?: string;
+  mode?: "pending" | "boundary";
+}
+export interface StreamRevealMetadata {
+  group: string;
+  index: number;
+  count: number;
+  order?: "as-ready" | "forwards" | "backwards" | "together";
+  tail?: "collapsed" | "hidden";
+}
 export interface BoundaryPatch {
   boundary: string;
   seq: number;
   html?: TemplateLike;
+  replace?: StreamReplacement | readonly StreamReplacement[];
+  attrs?: BuiltAttributePatchTriples | NoBuildAttributePatchTuples;
+  reveal?: StreamRevealMetadata;
   signals?: Record<string, unknown>;
   cache?: { browser?: Record<string, unknown> };
   redirect?: string;
@@ -526,17 +546,24 @@ export interface BoundaryPatch {
   meta?: Record<string, unknown>;
 }
 
+export interface BoundaryPatchCounts {
+  applied: number;
+  ignored?: number;
+}
+
 export type BoundaryApplyResult =
-  | { status: "applied"; boundary: string; seq: number }
+  | { status: "applied"; boundary: string; seq: number; attrs?: BoundaryPatchCounts; replace?: BoundaryPatchCounts }
+  | { status: "buffered"; boundary: string; seq: number; reveal: Required<Pick<StreamRevealMetadata, "group" | "index" | "count">> & Pick<StreamRevealMetadata, "order" | "tail"> }
   | { status: "ignored-stale"; boundary: string; seq: number; lastSeq: number }
   | { status: "ignored-destroyed"; boundary: string; seq: number; parentScope?: string }
-  | { status: "redirected"; boundary: string; seq: number; redirect: string }
+  | { status: "redirected"; boundary: string; seq: number; redirect: string; attrs?: BoundaryPatchCounts; replace?: BoundaryPatchCounts }
   | { status: "errored"; boundary: string; seq: number; error: Error };
 
 export interface BoundaryReceiverInspection {
   destroyed: boolean;
   boundaries: Record<string, { lastSeq: number; applied: number; ignored: number; errored?: number; lastStatus?: BoundaryApplyResult["status"] }>;
-  recent: Array<{ boundary: string; seq: number; status: BoundaryApplyResult["status"]; lastSeq?: number; parentScope?: string; redirect?: string }>;
+  reveal: Record<string, { count: number; order: string; tail?: string; pending: number[]; committed: number[] }>;
+  recent: Array<{ boundary: string; seq: number; status: BoundaryApplyResult["status"]; lastSeq?: number; parentScope?: string; redirect?: string; attrs?: BoundaryPatchCounts; replace?: BoundaryPatchCounts; reveal?: StreamRevealMetadata }>;
 }
 
 export interface BoundaryReceiverOptions {
@@ -545,6 +572,7 @@ export interface BoundaryReceiverOptions {
   cache?: CacheRegistry;
   scheduler?: Scheduler;
   router?: Router;
+  attributes?: AttributeConfig;
   onApply?(result: BoundaryApplyResult, patch: BoundaryPatch): void;
   onIgnore?(result: BoundaryApplyResult, patch: BoundaryPatch): void;
   onError?(error: Error, result: BoundaryApplyResult, patch: BoundaryPatch): void;
@@ -560,6 +588,18 @@ export interface BoundaryReceiver {
   destroy(): void;
 }
 
+export interface AsyncStreamApplyOptions extends Partial<BoundaryReceiverOptions> {
+  receiver?: BoundaryReceiver;
+  runtime?: AppRuntime;
+  root?: Document | Element | DocumentFragment;
+}
+
+export interface AsyncStreamNamespace {
+  applyScript(script: Element, options?: AsyncStreamApplyOptions): Promise<BoundaryApplyResult>;
+  applyCurrentScript(script?: Element, options?: AsyncStreamApplyOptions): Promise<BoundaryApplyResult>;
+  applyCurrentScript(options?: AsyncStreamApplyOptions): Promise<BoundaryApplyResult>;
+}
+
 export interface RegistryStore {
   target: RuntimeTarget;
   register(type: RegistryType, id: string, value: unknown): string;
@@ -696,6 +736,7 @@ export interface AsyncNamespace extends AppHub {
   inspectRoots: AppHub["inspectRoots"];
   attributeName: typeof attributeName;
   defineAttributeConfig: typeof defineAttributeConfig;
+  AsyncStream: AsyncStreamNamespace;
   createBoundaryReceiver: typeof createBoundaryReceiver;
   createCacheRegistry: typeof createCacheRegistry;
   defineCache: typeof defineCache;
@@ -736,6 +777,7 @@ export declare function defineApp(initial?: AppDefinition): AppHub;
 export declare function readSnapshot(root?: Document | Element, options?: { attributes?: AttributeConfig }): RegistryRuntimeSnapshot;
 export declare function attributeName(attributes: AttributeConfig | undefined, type: keyof NormalizedAttributeConfig, name: string): string;
 export declare function defineAttributeConfig(config?: AttributeConfig): NormalizedAttributeConfig;
+export declare const AsyncStream: AsyncStreamNamespace;
 export declare function createBoundaryReceiver(options: BoundaryReceiverOptions): BoundaryReceiver;
 export declare function createCacheRegistry(initialMap?: Record<string, CacheDefinition | CacheDefinitionOptions>, options?: { now?: () => number; registry?: RegistryStore; type?: "cache.browser" | "cache.server" }): CacheRegistry;
 export declare function defineCache(options?: CacheDefinitionOptions): CacheDefinition;