@czap/core 0.1.0

package/dist/component.js

@@ -0,0 +1,44 @@
+/**
+ * ComponentDef -- adaptive component primitive for constraint-based rendering.
+ *
+ * A component binds a boundary, styles, and named slots into a single
+ * content-addressed unit. Content-addressed via FNV-1a.
+ *
+ * @module
+ */
+import { CanonicalCbor } from './cbor.js';
+import { fnv1aBytes } from './fnv.js';
+function deterministicId(name, boundaryId, stylesId, slots, defaultSlot) {
+    return fnv1aBytes(CanonicalCbor.encode({
+        _tag: 'ComponentDef',
+        _version: 1,
+        name,
+        boundaryId: boundaryId ?? null,
+        stylesId,
+        slots,
+        defaultSlot: defaultSlot ?? null,
+    }));
+}
+/**
+ * Component — the content-addressed unit that binds a {@link Boundary}, a
+ * {@link Style}, and named slots into a single declaration compilers can
+ * target. The optional boundary gates style variants; the slots describe
+ * the consumer-facing API.
+ */
+export const Component = {
+    make(config) {
+        const id = deterministicId(config.name, config.boundary?.id, config.styles.id, config.slots, config.defaultSlot);
+        const def = {
+            _tag: 'ComponentDef',
+            _version: 1,
+            id,
+            name: config.name,
+            ...(config.boundary !== undefined ? { boundary: config.boundary } : {}),
+            styles: config.styles,
+            slots: config.slots,
+            ...(config.defaultSlot !== undefined ? { defaultSlot: config.defaultSlot } : {}),
+        };
+        return Object.freeze(def);
+    },
+};
+//# sourceMappingURL=component.js.map

package/dist/component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.js","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAgCtC,SAAS,eAAe,CACtB,IAAY,EACZ,UAA8B,EAC9B,QAAgB,EAChB,KAAwD,EACxD,WAAoB;IAEpB,OAAO,UAAU,CACf,aAAa,CAAC,MAAM,CAAC;QACnB,IAAI,EAAE,cAAc;QACpB,QAAQ,EAAE,CAAC;QACX,IAAI;QACJ,UAAU,EAAE,UAAU,IAAI,IAAI;QAC9B,QAAQ;QACR,KAAK;QACL,WAAW,EAAE,WAAW,IAAI,IAAI;KACjC,CAAC,CACH,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAqB;IACzC,IAAI,CAA4E,MAM/E;QACC,MAAM,EAAE,GAAG,eAAe,CAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE,EAAE,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;QAErH,MAAM,GAAG,GAAwB;YAC/B,IAAI,EAAE,cAAc;YACpB,QAAQ,EAAE,CAAC;YACX,EAAE;YACF,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,GAAG,CAAC,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACvE,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,GAAG,CAAC,MAAM,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACjF,CAAC;QACF,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC5B,CAAC;CACF,CAAC"}

package/dist/composable.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Composable -- ECS Composition over Existing Primitives
+ *
+ * Universal composition API leveraging existing deterministic primitives.
+ * Zero boilerplate, type-safe, content-addressed entity composition.
+ *
+ * @module
+ */
+import type { ContentAddress } from './brands.js';
+import type { Token } from './token.js';
+import type { Style } from './style.js';
+import type { World } from './ecs.js';
+import { Boundary } from './boundary.js';
+import { Part } from './ecs.js';
+import { Effect } from 'effect';
+/**
+ * Component map for a {@link ComposableEntity} — well-known slots for czap
+ * primitives plus arbitrary user-defined keys.
+ */
+export interface EntityComponents {
+    readonly boundary?: Boundary.Shape;
+    readonly token?: Token.Shape;
+    readonly style?: Style.Shape;
+    readonly [key: string]: unknown;
+}
+/**
+ * Content-addressed entity: the identity is an FNV-1a hash over its components,
+ * so two entities with structurally equal components share the same `id`.
+ */
+export interface ComposableEntity<T extends EntityComponents = EntityComponents> {
+    readonly id: ContentAddress;
+    readonly components: T;
+    readonly _tag: 'ComposableEntity';
+}
+interface ComposableFactory {
+    make<T extends EntityComponents>(components: T): ComposableEntity<T>;
+    compose<T extends EntityComponents>(entity1: ComposableEntity<T>, entity2: ComposableEntity<T>): ComposableEntity<T>;
+    merge<T extends EntityComponents>(...entities: ComposableEntity<T>[]): ComposableEntity<T>;
+}
+interface TypedComposableWorld<Schema extends EntityComponents = EntityComponents> {
+    spawn<T extends Schema>(components: T): Effect.Effect<ComposableEntity<T>>;
+    spawnWith<T extends Schema>(entity: ComposableEntity<T>): Effect.Effect<ComposableEntity<T>>;
+    query<K extends keyof Schema>(...componentTypes: K[]): Effect.Effect<readonly ComposableEntity<Pick<Schema, K>>[]>;
+    evaluate<T extends Schema>(entity: ComposableEntity<T>, input: Record<string, number>): Effect.Effect<Record<string, string>>;
+}
+declare function makeComposableWorld<Schema extends EntityComponents = EntityComponents>(world: World.Shape): TypedComposableWorld<Schema>;
+interface ComposableDenseStore {
+    create(name: string, capacity: number): Effect.Effect<Part.Dense>;
+    store<T extends EntityComponents>(entity: ComposableEntity<T>, value: number): Effect.Effect<void>;
+    retrieve<T extends EntityComponents>(entity: ComposableEntity<T>): Effect.Effect<number | undefined>;
+}
+declare function makeComposableDenseStore(world: World.Shape): ComposableDenseStore;
+/**
+ * Composable — content-addressed entity algebra over czap primitives.
+ *
+ * Build entities from a bag of components (boundaries, tokens, styles, …),
+ * merge them associatively via `Composable.compose` / `Composable.merge`, and
+ * rely on the content address to deduplicate structurally-equal entities.
+ */
+export declare const Composable: ComposableFactory;
+/**
+ * Bridge between a raw ECS {@link World} and typed {@link ComposableEntity}
+ * operations (`spawn`, `query`, `evaluate`) plus a thin dense-store integration.
+ */
+export declare const ComposableWorld: {
+    /** Wrap a {@link World} with the typed composable-entity API. */
+    make: typeof makeComposableWorld;
+    /** Build a dense-store bridge over a {@link World} for per-entity numeric data. */
+    dense: typeof makeComposableDenseStore;
+};
+export declare namespace ComposableWorld {
+    /** Structural shape of the typed world returned by {@link ComposableWorld.make}. */
+    type Shape<Schema extends EntityComponents = EntityComponents> = TypedComposableWorld<Schema>;
+}
+export type { TypedComposableWorld as ComposableWorldShape };
+//# sourceMappingURL=composable.d.ts.map

package/dist/composable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composable.d.ts","sourceRoot":"","sources":["../src/composable.ts"],"names":[],"mappings":"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"}

package/dist/composable.js

@@ -0,0 +1,221 @@
+/**
+ * Composable -- ECS Composition over Existing Primitives
+ *
+ * Universal composition API leveraging existing deterministic primitives.
+ * Zero boilerplate, type-safe, content-addressed entity composition.
+ *
+ * @module
+ */
+import { Token as TokenNS } from './token.js';
+import { Style as StyleNS } from './style.js';
+import { Boundary } from './boundary.js';
+import { Part } from './ecs.js';
+import { fnv1aBytes } from './fnv.js';
+import { TypedRef } from './typed-ref.js';
+import { Effect } from 'effect';
+function makeEntityId(components) {
+    const canonical = canonicalizeForAddress(components);
+    return fnv1aBytes(TypedRef.canonicalize(canonical));
+}
+function canonicalizeForAddress(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => {
+            const canonical = canonicalizeForAddress(entry);
+            return canonical === undefined ? null : canonical;
+        });
+    }
+    if (typeof value === 'object') {
+        const entries = Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [key, canonicalizeForAddress(entry)]);
+        return Object.fromEntries(entries);
+    }
+    return String(value);
+}
+function _make(components) {
+    const id = makeEntityId(components);
+    return {
+        id,
+        components,
+        _tag: 'ComposableEntity',
+    };
+}
+function _compose(entity1, entity2) {
+    // Merge components with entity2 taking precedence
+    const merged = { ...entity1.components, ...entity2.components };
+    return _make(merged);
+}
+function _merge(...entities) {
+    if (entities.length === 0) {
+        throw new Error('Cannot merge zero entities');
+    }
+    const first = entities[0];
+    if (!first) {
+        throw new Error('First entity is undefined');
+    }
+    return entities.slice(1).reduce((acc, entity) => _compose(acc, entity), first);
+}
+// ---------------------------------------------------------------------------
+// ECS Integration
+// ---------------------------------------------------------------------------
+/**
+ * Convert a runtime `Map<string, unknown>` (from ECS query results) into a typed
+ * `Pick<Schema, K>`. The ECS query filters guarantee the required keys are present;
+ * this helper contains the one boundary cast where runtime shape joins the type lattice.
+ */
+function entriesToPick(components) {
+    return Object.fromEntries(components);
+}
+function makeComposableWorld(world) {
+    // Mapping from ContentAddress to ECS EntityId for query reconstruction
+    const addressToEntityId = new Map();
+    return {
+        spawn(components) {
+            return Effect.gen(function* () {
+                const entity = _make(components);
+                const ecsId = yield* world.spawn(components);
+                addressToEntityId.set(entity.id, ecsId);
+                return entity;
+            });
+        },
+        spawnWith(entity) {
+            return Effect.gen(function* () {
+                const ecsId = yield* world.spawn(entity.components);
+                addressToEntityId.set(entity.id, ecsId);
+                return entity;
+            });
+        },
+        query(...componentTypes) {
+            return Effect.gen(function* () {
+                const names = [...componentTypes].map((k) => String(k)).sort();
+                const entities = yield* world.query(...names);
+                return [...entities]
+                    .sort((left, right) => left.id.localeCompare(right.id))
+                    .map((entityShape) => {
+                    // world.query guarantees entityShape.components contains at least the K keys
+                    // that were queried for; convert the runtime Map<string, unknown> to the typed
+                    // Pick<Schema, K> via a single contained cast (runtime shape is validated by
+                    // the ECS query filter).
+                    const components = entriesToPick(entityShape.components);
+                    return _make(components);
+                });
+            });
+        },
+        evaluate(entity, input) {
+            return Effect.gen(function* () {
+                const results = {};
+                // Evaluate boundary component: quantize continuous input to discrete state
+                let boundaryState;
+                if (entity.components.boundary) {
+                    const boundary = entity.components.boundary;
+                    const boundaryInput = input[boundary.input] ?? 0;
+                    const state = Boundary.evaluate(boundary, boundaryInput);
+                    results[boundary.input] = state;
+                    boundaryState = state;
+                }
+                // Evaluate token component: resolve axis values or fall back
+                if (entity.components.token) {
+                    const token = entity.components.token;
+                    // Build axis values from input keys. Token.tap expects string axis values,
+                    // so we convert matching numeric inputs to strings.
+                    const axisValues = {};
+                    for (const axis of token.axes) {
+                        if (axis in input) {
+                            axisValues[axis] = String(input[axis]);
+                        }
+                    }
+                    // Use Token.tap for proper axis-key lookup with fallback
+                    const resolved = TokenNS.tap(token, axisValues);
+                    results[token.name] = String(resolved);
+                }
+                // Evaluate style component: resolve properties for the current boundary state
+                if (entity.components.style) {
+                    const style = entity.components.style;
+                    const resolvedProps = StyleNS.tap(style, boundaryState);
+                    for (const [prop, val] of Object.entries(resolvedProps)) {
+                        results[prop] = val;
+                    }
+                }
+                return results;
+            });
+        },
+    };
+}
+function makeComposableDenseStore(world) {
+    // Maintain a mapping from ContentAddress to ECS EntityId for dense store ops
+    const addressToEntityId = new Map();
+    let denseStore;
+    return {
+        create(name, capacity) {
+            return Effect.gen(function* () {
+                const store = Part.dense(name, capacity);
+                yield* world.addDenseStore(store);
+                denseStore = store;
+                return store;
+            });
+        },
+        store(entity, value) {
+            return Effect.gen(function* () {
+                if (!denseStore) {
+                    throw new Error('No dense store created. Call create() first.');
+                }
+                // Ensure we have an ECS EntityId for this composable entity
+                let ecsId = addressToEntityId.get(entity.id);
+                if (!ecsId) {
+                    // Spawn into the world to get an EntityId, then track mapping
+                    ecsId = yield* world.spawn(entity.components);
+                    addressToEntityId.set(entity.id, ecsId);
+                }
+                denseStore.set(ecsId, value);
+            });
+        },
+        retrieve(entity) {
+            return Effect.gen(function* () {
+                if (!denseStore) {
+                    return undefined;
+                }
+                const ecsId = addressToEntityId.get(entity.id);
+                if (!ecsId) {
+                    return undefined;
+                }
+                return denseStore.get(ecsId);
+            });
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+/**
+ * Composable — content-addressed entity algebra over czap primitives.
+ *
+ * Build entities from a bag of components (boundaries, tokens, styles, …),
+ * merge them associatively via `Composable.compose` / `Composable.merge`, and
+ * rely on the content address to deduplicate structurally-equal entities.
+ */
+export const Composable = {
+    /** Content-address a component bag into a {@link ComposableEntity}. */
+    make: _make,
+    /** Pairwise merge — right-biased; produces a new entity with a fresh content address. */
+    compose: _compose,
+    /** Variadic `Composable.compose`. Throws if called with zero entities. */
+    merge: _merge,
+};
+/**
+ * Bridge between a raw ECS {@link World} and typed {@link ComposableEntity}
+ * operations (`spawn`, `query`, `evaluate`) plus a thin dense-store integration.
+ */
+export const ComposableWorld = {
+    /** Wrap a {@link World} with the typed composable-entity API. */
+    make: makeComposableWorld,
+    /** Build a dense-store bridge over a {@link World} for per-entity numeric data. */
+    dense: makeComposableDenseStore,
+};
+//# sourceMappingURL=composable.js.map

package/dist/composable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composable.js","sourceRoot":"","sources":["../src/composable.ts"],"names":[],"mappings":"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"}

package/dist/compositor-pool.d.ts

@@ -0,0 +1,74 @@
+/**
+ * CompositorStatePool -- ring buffer of pre-allocated CompositeState objects.
+ *
+ * The compositor grabs one, writes into it, hands it to the renderer,
+ * which returns it after DOM application. Zero-allocation hot path.
+ *
+ * @module
+ */
+import type { CompositeState } from './compositor.js';
+interface CompositorStatePoolShape {
+    acquire(): CompositeState;
+    release(state: CompositeState): void;
+    readonly size: number;
+    readonly available: number;
+}
+/**
+ * Mutable views into a CompositeState's fields. `CompositeState` declares
+ * its fields as `readonly Record<...>`, but the compositor and the pool
+ * both need to mutate those records in place for the zero-allocation
+ * hot path. This helper centralises the single cast that strips
+ * `readonly` so callers can stay type-safe without re-casting at each
+ * write site.
+ */
+export interface MutableCompositeStateViews {
+    readonly discrete: Record<string, string>;
+    readonly blend: Record<string, Record<string, number>>;
+    readonly css: Record<string, number | string>;
+    readonly glsl: Record<string, number>;
+    readonly aria: Record<string, string>;
+}
+/**
+ * Expose the inner `Record<…>`s of a {@link CompositeState} as mutable views
+ * for the zero-allocation hot path. Single sanctioned site that strips
+ * `readonly` — do not cast at other call sites.
+ */
+export declare function accessCompositeState(state: CompositeState): MutableCompositeStateViews;
+/**
+ * Creates a ring-buffer pool of pre-allocated CompositeState objects.
+ * Acquire/release pattern avoids GC allocations on the hot render path.
+ * Default 8 slots -- enough for typical compositor with 4-6 quantizers + headroom.
+ *
+ * @example
+ * ```ts
+ * const pool = CompositorStatePool.make(4);
+ * const state = pool.acquire();
+ * state.discrete['theme'] = 'dark';
+ * state.outputs.css['--bg'] = '#000';
+ * pool.release(state); // resets and returns to pool
+ * pool.available; // 4
+ * ```
+ */
+declare function _make(capacity?: number): CompositorStatePoolShape;
+/**
+ * CompositorStatePool -- ring buffer of pre-allocated CompositeState objects.
+ * Zero-allocation hot path: acquire a state, write into it, render, then release.
+ *
+ * @example
+ * ```ts
+ * const pool = CompositorStatePool.make(8);
+ * const state = pool.acquire();
+ * // Write compositor output into state.discrete, state.blend, state.outputs
+ * pool.release(state); // resets and returns to pool
+ * console.log(pool.size, pool.available); // 8, 8
+ * ```
+ */
+export declare const CompositorStatePool: {
+    make: typeof _make;
+};
+export declare namespace CompositorStatePool {
+    /** Structural shape of a pool instance: `acquire`, `release`, `size`, `available`. */
+    type Shape = CompositorStatePoolShape;
+}
+export {};
+//# sourceMappingURL=compositor-pool.d.ts.map

package/dist/compositor-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositor-pool.d.ts","sourceRoot":"","sources":["../src/compositor-pool.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAKtD,UAAU,wBAAwB;IAChC,OAAO,IAAI,cAAc,CAAC;IAC1B,OAAO,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACvD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC;AAUD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,cAAc,GAAG,0BAA0B,CAStF;AAoBD;;;;;;;;;;;;;;GAcG;AACH,iBAAS,KAAK,CAAC,QAAQ,SAAsB,GAAG,wBAAwB,CA+CvE;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB;;CAAkB,CAAC;AAEnD,MAAM,CAAC,OAAO,WAAW,mBAAmB,CAAC;IAC3C,sFAAsF;IACtF,KAAY,KAAK,GAAG,wBAAwB,CAAC;CAC9C"}

package/dist/compositor-pool.js

@@ -0,0 +1,119 @@
+/**
+ * CompositorStatePool -- ring buffer of pre-allocated CompositeState objects.
+ *
+ * The compositor grabs one, writes into it, hands it to the renderer,
+ * which returns it after DOM application. Zero-allocation hot path.
+ *
+ * @module
+ */
+import { COMPOSITOR_POOL_CAP } from './defaults.js';
+/**
+ * Expose the inner `Record<…>`s of a {@link CompositeState} as mutable views
+ * for the zero-allocation hot path. Single sanctioned site that strips
+ * `readonly` — do not cast at other call sites.
+ */
+export function accessCompositeState(state) {
+    const mutable = state;
+    return {
+        discrete: mutable.discrete,
+        blend: mutable.blend,
+        css: mutable.outputs.css,
+        glsl: mutable.outputs.glsl,
+        aria: mutable.outputs.aria,
+    };
+}
+function createMutableState() {
+    return {
+        discrete: {},
+        blend: {},
+        outputs: { css: {}, glsl: {}, aria: {} },
+    };
+}
+function resetState(state) {
+    // Clear all fields in-place (cheaper than allocation)
+    const { discrete, blend, css, glsl, aria } = accessCompositeState(state);
+    for (const k of Object.keys(discrete))
+        delete discrete[k];
+    for (const k of Object.keys(blend))
+        delete blend[k];
+    for (const k of Object.keys(css))
+        delete css[k];
+    for (const k of Object.keys(glsl))
+        delete glsl[k];
+    for (const k of Object.keys(aria))
+        delete aria[k];
+}
+/**
+ * Creates a ring-buffer pool of pre-allocated CompositeState objects.
+ * Acquire/release pattern avoids GC allocations on the hot render path.
+ * Default 8 slots -- enough for typical compositor with 4-6 quantizers + headroom.
+ *
+ * @example
+ * ```ts
+ * const pool = CompositorStatePool.make(4);
+ * const state = pool.acquire();
+ * state.discrete['theme'] = 'dark';
+ * state.outputs.css['--bg'] = '#000';
+ * pool.release(state); // resets and returns to pool
+ * pool.available; // 4
+ * ```
+ */
+function _make(capacity = COMPOSITOR_POOL_CAP) {
+    const buffer = [];
+    for (let i = 0; i < capacity; i++) {
+        buffer.push(createMutableState());
+    }
+    const free = new Array(capacity).fill(true);
+    let acquirePtr = 0;
+    return {
+        acquire() {
+            // Scan from current pointer for a free slot
+            for (let i = 0; i < capacity; i++) {
+                const idx = (acquirePtr + i) % capacity;
+                if (free[idx]) {
+                    free[idx] = false;
+                    acquirePtr = (idx + 1) % capacity;
+                    return buffer[idx];
+                }
+            }
+            // All slots in use — allocate overflow (cold path)
+            const overflow = createMutableState();
+            buffer.push(overflow);
+            free.push(false);
+            return overflow;
+        },
+        release(state) {
+            const idx = buffer.indexOf(state);
+            if (idx !== -1) {
+                resetState(state);
+                free[idx] = true;
+            }
+        },
+        get size() {
+            return buffer.length;
+        },
+        get available() {
+            let count = 0;
+            for (let i = 0; i < free.length; i++) {
+                if (free[i])
+                    count++;
+            }
+            return count;
+        },
+    };
+}
+/**
+ * CompositorStatePool -- ring buffer of pre-allocated CompositeState objects.
+ * Zero-allocation hot path: acquire a state, write into it, render, then release.
+ *
+ * @example
+ * ```ts
+ * const pool = CompositorStatePool.make(8);
+ * const state = pool.acquire();
+ * // Write compositor output into state.discrete, state.blend, state.outputs
+ * pool.release(state); // resets and returns to pool
+ * console.log(pool.size, pool.available); // 8, 8
+ * ```
+ */
+export const CompositorStatePool = { make: _make };
+//# sourceMappingURL=compositor-pool.js.map

package/dist/compositor-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compositor-pool.js","sourceRoot":"","sources":["../src/compositor-pool.ts"],"names":[],"mappings":"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"}

package/dist/compositor.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Compositor -- merge multiple quantizers into composite state.
+ *
+ * The compositor aggregates discrete + blended state from all
+ * active quantizers into a single CompositeState, producing
+ * typed output channels (css, glsl, aria).
+ *
+ * Wired: DirtyFlags (selective recomputation), CompositorStatePool
+ * (zero-allocation), FrameBudget (priority scheduling), microtask batching,
+ * and RuntimeCoordinator (Plan + ECS-backed runtime bookkeeping).
+ *
+ * Hot path (computeStateSync) is plain JS — no Effect overhead.
+ * Effect is used only for resource lifecycle (create/scope) and
+ * reactive stream (SubscriptionRef.changes).
+ *
+ * @module
+ */
+import type { Scope, Stream } from 'effect';
+import { Effect } from 'effect';
+import type { Boundary } from './boundary.js';
+import type { FrameBudget } from './frame-budget.js';
+import type { Quantizer } from './quantizer-types.js';
+import { RuntimeCoordinator } from './runtime-coordinator.js';
+/**
+ * Snapshot of the compositor's output per tick: discrete state names for each
+ * quantizer, their blend-weight vectors, and the compiled per-target output
+ * maps (`css` / `glsl` / `aria`).
+ */
+export interface CompositeState {
+    readonly discrete: Record<string, string>;
+    readonly blend: Record<string, Record<string, number>>;
+    readonly outputs: {
+        readonly css: Record<string, number | string>;
+        readonly glsl: Record<string, number>;
+        readonly aria: Record<string, string>;
+    };
+}
+/**
+ * Options accepted by `Compositor.create`: pool capacity, optional
+ * frame-budget gating, and whether to enable speculative pre-evaluation.
+ */
+export interface CompositorConfig {
+    readonly poolCapacity?: number;
+    readonly frameBudget?: FrameBudget.Shape;
+    readonly speculative?: boolean;
+}
+interface CompositorShape {
+    add<B extends Boundary.Shape>(name: string, quantizer: Quantizer<B>): Effect.Effect<void>;
+    remove(name: string): Effect.Effect<void>;
+    compute(): Effect.Effect<CompositeState>;
+    setBlendWeights(name: string, weights: Record<string, number>): Effect.Effect<void>;
+    evaluateSpeculative(name: string, value: number, velocity?: number): void;
+    scheduleBatch(): void;
+    readonly changes: Stream.Stream<CompositeState>;
+    readonly runtime: RuntimeCoordinator.Shape;
+}
+interface CompositorFactory {
+    create(config?: CompositorConfig): Effect.Effect<CompositorShape, never, Scope.Scope>;
+}
+/**
+ * Compositor — the live merge point for every attached {@link Quantizer}.
+ *
+ * `Compositor.create` hands back a scoped Effect that, when run inside a
+ * `Scope`, produces a compositor bound to a {@link RuntimeCoordinator}. Adding
+ * quantizers, marking dirty flags, and emitting CSS/GLSL/ARIA outputs all flow
+ * through the zero-allocation hot path backed by {@link CompositorStatePool}.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Compositor } from '@czap/core';
+ *
+ * const program = Effect.scoped(Effect.gen(function* () {
+ *   const compositor = yield* Compositor.create({ poolCapacity: 64, speculative: true });
+ *   yield* compositor.add('viewport', viewportQuantizer);
+ *   const state = yield* compositor.compute();
+ *   // state.discrete.viewport === 'tablet'
+ *   // state.outputs.css['--czap-viewport'] === 'tablet'
+ * }));
+ * ```
+ */
+export declare const Compositor: CompositorFactory;
+export declare namespace Compositor {
+    /** Structural shape of a live compositor instance. */
+    type Shape = CompositorShape;
+    /** Alias for {@link CompositorConfig}. */
+    type Config = CompositorConfig;
+}
+export {};
+//# sourceMappingURL=compositor.d.ts.map