@forgeax/engine-ecs 0.1.2

package/dist/relationship-index.d.ts

@@ -0,0 +1,81 @@
+import { type Component, type ComponentSchema } from './component';
+import type { EntityHandle } from './entity-handle';
+declare const relationshipTargetBrand: unique symbol;
+/** A relationship target is a read projection, never a structural-write token. */
+export type RelationshipTargetComponent<C extends Component = Component> = C & {
+    readonly [relationshipTargetBrand]: true;
+};
+/** The two immutable roles produced by one relationship declaration. */
+export interface RelationshipDefinition {
+    readonly source: Component<string, ComponentSchema>;
+    readonly target: RelationshipTargetComponent<Component<string, ComponentSchema>>;
+}
+export interface RelationshipOptions {
+    readonly sourceName: string;
+    readonly sourceField: string;
+    readonly targetName: string;
+    readonly targetField: string;
+    readonly exclusive?: boolean;
+    readonly linkedSpawn?: boolean;
+    /** Allow a source to point at its own holder (e.g. self-animated entities). */
+    readonly allowSelf?: boolean;
+}
+export type RelationshipRole = {
+    readonly kind: 'source';
+    readonly target: Component<string, ComponentSchema>;
+    readonly sourceField: string;
+    readonly targetField: string;
+    readonly exclusive: boolean;
+    readonly linkedSpawn: boolean;
+    readonly allowSelf: boolean;
+} | {
+    readonly kind: 'target';
+    readonly source: Component<string, ComponentSchema>;
+    readonly sourceField: string;
+    readonly targetField: string;
+};
+/**
+ * Declare both sides of a relationship in one closed operation. The source is
+ * the only writable relationship component; its target is a materialized,
+ * engine-maintained reverse list.
+ */
+export declare function defineRelationship<const S extends string, const SF extends string, const T extends string, const TF extends string>(options: RelationshipOptions & {
+    readonly sourceName: S;
+    readonly sourceField: SF;
+    readonly targetName: T;
+    readonly targetField: TF;
+}): {
+    readonly source: Component<S, {
+        [K in SF]: 'entity';
+    }>;
+    readonly target: RelationshipTargetComponent<Component<T, {
+        [K in TF]: 'array<entity>';
+    }>>;
+};
+export declare function relationshipRole(component: Component): RelationshipRole | undefined;
+/** Return the materialized target token owned by a source relationship. */
+export declare function relationshipMirror(component: Component): Component | undefined;
+/** Return the source token owned by a materialized relationship target. */
+export declare function relationshipSource(component: Component): Component | undefined;
+export declare function isRelationshipTarget(component: Component): boolean;
+/**
+ * Backpointer index for the materialized reverse lists stored by World.
+ * The target component array is the one authoritative read list; this index
+ * stores only source-to-target locations for O(1) swap-remove bookkeeping.
+ */
+export declare class RelationshipIndex {
+    private readonly slots;
+    private epochValue;
+    get epoch(): number;
+    attach(source: EntityHandle, target: EntityHandle, slot: number): number;
+    detach(source: EntityHandle): boolean;
+    reparent(source: EntityHandle, target: EntityHandle, slot: number): number;
+    slotOf(source: EntityHandle): number | undefined;
+    targetOf(source: EntityHandle): EntityHandle | undefined;
+    /** Bind the source that swap-remove moved into `slot`. */
+    updateSlot(source: EntityHandle, target: EntityHandle, slot: number): void;
+    /** Cold recovery path only: rebuild from R source records. */
+    recover(records: Iterable<readonly [EntityHandle, EntityHandle]>): void;
+}
+export {};
+//# sourceMappingURL=relationship-index.d.ts.map

package/dist/relationship-index.d.ts.map

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

package/dist/resource.d.ts

@@ -0,0 +1,70 @@
+/** Internal resource storage. */
+export interface ResourceEntry {
+    value: unknown;
+    added: number;
+    changed: number;
+}
+export interface ResourceStore {
+    readonly entries: Map<string, ResourceEntry>;
+}
+/** Create a fresh resource store. */
+export declare function createResourceStore(): ResourceStore;
+/**
+ * Insert or overwrite a resource (idempotent, E-13).
+ *
+ * @example
+ * ```ts
+ * import { createResourceStore, insertResource, type ResourceStore } from './resource';
+ *
+ * const store: ResourceStore = createResourceStore();
+ * insertResource(store, 'health', 100);
+ * // overwriting is idempotent (no error / no duplicate slot):
+ * insertResource(store, 'health', 95);
+ * ```
+ */
+export declare function insertResource<T>(store: ResourceStore, key: string, value: T, epoch?: number): void;
+/**
+ * Get a resource by key.
+ * @throws ResourceNotFoundError if key does not exist (E-14).
+ *
+ * @example
+ * ```ts
+ * import { getResource, insertResource, type ResourceStore } from './resource';
+ *
+ * declare const store: ResourceStore;
+ * insertResource(store, 'health', 100);
+ * const hp = getResource<number>(store, 'health');
+ * // hp === 100; throws ResourceNotFoundError on missing key (charter proposition 4)
+ * ```
+ */
+export declare function getResource<T>(store: ResourceStore, key: string): T;
+/**
+ * Check if a resource exists.
+ *
+ * @example
+ * ```ts
+ * import { hasResource, insertResource, type ResourceStore } from './resource';
+ *
+ * declare const store: ResourceStore;
+ * insertResource(store, 'health', 100);
+ * if (hasResource(store, 'health')) {
+ *   // guarded access avoids ResourceNotFoundError from getResource
+ * }
+ * ```
+ */
+export declare function hasResource(store: ResourceStore, key: string): boolean;
+/**
+ * Remove a resource by key.
+ *
+ * @example
+ * ```ts
+ * import { hasResource, insertResource, removeResource, type ResourceStore } from './resource';
+ *
+ * declare const store: ResourceStore;
+ * insertResource(store, 'health', 100);
+ * removeResource(store, 'health');
+ * // hasResource(store, 'health') === false; idempotent on missing keys
+ * ```
+ */
+export declare function removeResource(store: ResourceStore, key: string): boolean;
+//# sourceMappingURL=resource.d.ts.map

package/dist/resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../src/resource.ts"],"names":[],"mappings":"AAWA,iCAAiC;AACjC,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CAC9C;AAED,qCAAqC;AACrC,wBAAgB,mBAAmB,IAAI,aAAa,CAEnD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,SAAI,GAAG,IAAI,CAQ9F;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,CAMnE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAEtE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAEzE"}

package/dist/schedule-token.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Nominal label for one of the World-owned schedules.
+ *
+ * Worlds expose the built-in tokens below. A token is both a registration
+ * scope and, for FixedUpdate, the intrinsic Update ordering anchor.
+ */
+export interface ScheduleToken {
+    readonly name: string;
+}
+export type ScheduleName = 'Update' | 'FixedUpdate';
+/** Variable-rate World schedule. */
+export declare const Update: ScheduleToken;
+/** Fixed-rate World schedule and the intrinsic Update ordering anchor. */
+export declare const FixedUpdate: ScheduleToken;
+export declare function isScheduleToken(value: unknown): value is ScheduleToken;
+//# sourceMappingURL=schedule-token.d.ts.map

package/dist/schedule-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-token.d.ts","sourceRoot":"","sources":["../src/schedule-token.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,aAAa,CAAC;AAuBpD,oCAAoC;AACpC,eAAO,MAAM,MAAM,eAAgC,CAAC;AACpD,0EAA0E;AAC1E,eAAO,MAAM,WAAW,eAAqC,CAAC;AAC9D,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE"}

package/dist/schedule.d.ts

@@ -0,0 +1,271 @@
+import { type Result } from '@forgeax/engine-types';
+import { type CommandBuffer } from './commands';
+import type { Component } from './component';
+import { ScheduleMutationError, type SystemSetNotRegisteredError } from './errors';
+import type { Query, QueryDescriptor } from './query/query';
+import type { ScheduleToken } from './schedule-token';
+import type { World } from './world';
+type SystemQueryResults<Qs extends ReadonlyArray<QueryDescriptor> = ReadonlyArray<QueryDescriptor>> = {
+    [K in keyof Qs]: Qs[K] extends QueryDescriptor<infer R extends ReadonlyArray<Component>, infer W extends ReadonlyArray<Component>, infer O extends ReadonlyArray<Component>> ? Query<NoInfer<R>, NoInfer<W>, NoInfer<O>> : Query;
+};
+/**
+ * System descriptor passed to `world.addSystem` — `fn` receives one persistent
+ * executable Query per descriptor, mapped over `Qs` without casts.
+ *
+ * `Qs` is the tuple of query descriptors; defaults to
+ * `readonly QueryDescriptor[]` so non-generic call sites stay zero-modification
+ * (KD-5). The `fn` first parameter is mapped over `Qs` so each
+ * `queryResults[i]` recovers its own row access roles (S-5, KD-2).
+ *
+ * @example
+ * ```ts
+ * // Single-query system — row access recovers each component schema.
+ * import { defineComponent, World } from '@forgeax/engine-ecs';
+ *
+ * const Position = defineComponent('Position', { x: 'f32', y: 'f32' });
+ * const Velocity = defineComponent('Velocity', { dx: 'f32', dy: 'f32' });
+ *
+ * const world = new World();
+ * world.addSystem(Update, {
+ *   name: 'movement',
+ *   queries: [{ write: [Position], read: [Velocity] }],
+ *   fn: (_world, queryResults, _commands) => {
+ *     for (const row of queryResults[0]) {
+ *       row.mut(Position).x += row.get(Velocity).dx;
+ *     }
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Multi-query system — each queryResults[i] keeps its own row shape.
+ * const Health = defineComponent('Health', { hp: 'f32' });
+ * world.addSystem(Update, {
+ *   name: 'multi',
+ *   queries: [{ read: [Position] }, { read: [Health] }],
+ *   fn: (_world, queryResults) => {
+ *     for (const row of queryResults[0]) void row.get(Position).x;
+ *     for (const row of queryResults[1]) void row.get(Health).hp;
+ *   },
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Commands-only system — `queries: []` is a legal form; fn receives `[]`.
+ * world.addSystem(Update, {
+ *   name: 'spawner',
+ *   queries: [],
+ *   fn: (_world, _queryResults, commands) => {
+ *     commands.spawn({ component: Position, data: { x: 0, y: 0 } });
+ *   },
+ * });
+ * ```
+ */
+export interface SystemDescriptor<Qs extends ReadonlyArray<QueryDescriptor> = ReadonlyArray<QueryDescriptor>> {
+    /** Unique system name (used for before/after references). */
+    readonly name: string;
+    /** Query descriptors this system reads. */
+    readonly queries: Qs;
+    /**
+     * System function — receives the World, resolved query results, and commands.
+     *
+     * @param world The owning World — read resources (`world.getResource(KEY)`),
+     * resolve components by name, etc. without closure capture.
+     * @param queryResults Mapped over `Qs`: each entry is a persistent Query.
+     * @param commands Deferred-mutation buffer (flushed after the system).
+     */
+    readonly fn: (world: World, queryResults: SystemQueryResults<Qs>, commands: CommandBuffer) => void | unknown;
+    /** Run this system after named systems or the FixedUpdate anchor. */
+    readonly after?: ReadonlyArray<string | ScheduleToken>;
+    /** Run this system before named systems or the FixedUpdate anchor. */
+    readonly before?: ReadonlyArray<string | ScheduleToken>;
+    /**
+     * Run condition. Evaluated each frame after ParamValidation passes (tag
+     * 'ok') and before query iteration. Returning `false` skips the system silently —
+     * no query runs, no fn call, no state added (plan-strategy D-8). Omitting it
+     * (undefined) always runs the system.
+     */
+    readonly runIf?: (world: World) => boolean;
+}
+/**
+ * A registered system token returned by {@link defineSystem}. Structurally the
+ * frozen {@link SystemDescriptor} itself (plan-strategy D-6 — "define ==
+ * register"). `world.addSystem(handle)` consumes it directly; the generic `Qs`
+ * flows through so the `fn` per-query row access shapes survive (S-5).
+ */
+export type SystemHandle<Qs extends ReadonlyArray<QueryDescriptor> = ReadonlyArray<QueryDescriptor>> = SystemDescriptor<Qs>;
+/** Internal system record with registration index. */
+interface SystemRecord {
+    descriptor: SystemDescriptor;
+    /** Registration order index (for tie-breaking). */
+    registrationIndex: number;
+    /** Cached executable Queries, one per descriptor. */
+    queries: Query[] | null;
+}
+/**
+ * Per-set record in the Schedule. Created lazily on first addSystems /
+ * addSystems call for a given set name.
+ */
+export interface SetRecord {
+    /** Member system names (insertion-ordered, Set preserves add order). */
+    readonly members: Set<string>;
+    /** Snapshot of runIf from the defining token. */
+    readonly runIf: ((world: import('./world').World) => boolean) | undefined;
+    /** Snapshot of chained from the defining token. */
+    readonly chained: boolean;
+}
+/** The Schedule manages system registration, DAG sorting, and execution. */
+export interface Schedule {
+    /** Owning token for scope-aware diagnostics. */
+    readonly token: ScheduleToken;
+    /** All registered systems by name. */
+    systems: Map<string, SystemRecord>;
+    /** Set records keyed by set name. Created lazily. */
+    sets: Map<string, SetRecord>;
+    /** Next registration index. */
+    nextIndex: number;
+    /** Whether the sorted order is stale. */
+    dirty: boolean;
+    /** Sorted system names after buildSchedule(). */
+    sortedOrder: string[];
+    /** Direct predecessor names derived while the DAG is built. */
+    predecessors: Map<string, Set<string>>;
+}
+/** Create a fresh Schedule. */
+export declare function createSchedule(token: ScheduleToken): Schedule;
+/**
+ * Register a system. Marks schedule as dirty.
+ * Queries are lazily initialized on first runSchedule.
+ *
+ * `const Qs` locks the `queries` tuple at the call site so `fn`'s first
+ * parameter recovers per-query row shapes without `as const` annotations
+ * (S-5, KD-2). `SystemRecord` itself is intentionally non-generic — the
+ * heterogeneous `Qs` cannot be expressed inside the systems Map (KD-3).
+ */
+export declare function addSystem<const Qs extends ReadonlyArray<QueryDescriptor>>(schedule: Schedule, descriptor: SystemDescriptor<Qs>): void;
+/**
+ * Define a system at module level. Returns a frozen {@link SystemHandle} token
+ * (the descriptor itself); executable registration is World-local.
+ *
+ * `world.addSystem(handle)` consumes the token directly — no by-name overload
+ * (OOS-8). Duplicate names are resolved by the owning World schedule.
+ *
+ * `const Qs` locks the `queries` tuple so `fn`'s query-results parameter
+ * recovers per-query row access shapes without `as const` (S-5).
+ *
+ * @example
+ * ```ts
+ * const Move = defineSystem({
+ *   name: 'movement',
+ *   queries: [{ with: [Position, Velocity] }],
+ *   fn: (_world, queryResults) => { ... },
+ * });
+ * world.addSystem(Move);
+ * ```
+ */
+export declare function defineSystem<const Qs extends ReadonlyArray<QueryDescriptor>>(descriptor: SystemDescriptor<Qs>): SystemHandle<Qs>;
+/**
+ */
+/** Brand symbol for {@link SystemSet}. Declared (not runtime-initialised) so
+ * the token interface carries nominal identity without a runtime allocation.
+ * Mirrors the `FORGEAX_STATE_BRAND` pattern in `@forgeax/engine-state`. */
+declare const FORGEAX_SYSTEM_SET_BRAND: unique symbol;
+/**
+ * Opaque branded type for system-set tokens.
+ *
+ * Use {@link defineSystemSet} to create a token; never construct manually.
+ * The {@link __forgeaxSystemSet} brand prevents plain-object assignment and
+ * enables TypeScript narrowing at the two mutation entry points.
+ */
+export interface SystemSet {
+    /** Brand — prevents structural compatibility with plain objects. */
+    readonly __forgeaxSystemSet: typeof FORGEAX_SYSTEM_SET_BRAND;
+    /** The user-supplied set name. */
+    readonly name: string;
+    /** Optional per-frame run condition. Consumed by M3 condition gate. */
+    readonly runIf?: (world: import('./world').World) => boolean;
+    /** Whether this set forms a sequential chain (M2). */
+    readonly chained?: boolean;
+}
+/**
+ * Define a system set at module level. Returns a frozen branded token and
+ * keeps membership in the World-local Schedule.
+ *
+ * Duplicate names are independent tokens; the owning World decides membership.
+ *
+ * @example
+ * ```ts
+ * const GameplaySet = defineSystemSet({ name: 'gameplay', runIf: (w) => !w.getResource<boolean>('paused') });
+ * const OrderedSet = defineSystemSet({ name: 'ordered', chained: true });
+ * ```
+ */
+export declare function defineSystemSet(opts: {
+    readonly name: string;
+    readonly runIf?: (world: import('./world').World) => boolean;
+    readonly chained?: boolean;
+}): SystemSet;
+/**
+/**
+ * Validate every token in `tokens` for local structural validity.
+ * Returns `ok(undefined)` for a structurally valid token and reports an empty
+ * token name as a structured registration error.
+ *
+ * Does not write any Schedule state — callers consume the `Result` and proceed
+ * only on `ok`.
+ */
+export declare function validateSystemSetTokens(tokens: readonly SystemSet[]): Result<void, SystemSetNotRegisteredError>;
+/**
+ * Remove a registered system by name (M2 — plan-strategy D-3).
+ *
+ * Drops the entry from `schedule.systems` and marks the schedule dirty so the
+ * next `runSchedule` rebuilds the sorted order via Kahn topo. Cycle detection
+ * already happens inside `buildSchedule`, so a removal that breaks an unrelated
+ * `before/after` reference simply skips the unknown name (existing behaviour).
+ *
+ * Failure: name not registered → `Result.err(ScheduleMutationError)` with
+ * `.code = 'system-before-unknown'` and `.detail.candidates` carrying the
+ * registered names for AI-friendly typo recovery.
+ */
+export declare function removeSystem(schedule: Schedule, name: string): Result<void, ScheduleMutationError>;
+/**
+ * Replace a registered system in-place (M2 — plan-strategy D-3 atomic semantics).
+ *
+ * Overwrites the `descriptor` field of the existing `SystemRecord` while
+ * keeping `registrationIndex` and the `Map` slot identical, so all `before /
+ * after` edges that reference this name remain bound to the same slot. Marks
+ * the schedule dirty: the next `runSchedule` re-sorts.
+ *
+ * Failure: name not registered → `Result.err(ScheduleMutationError)` with
+ * `.code = 'system-before-unknown'`.
+ */
+export declare function replaceSystem<const Qs extends ReadonlyArray<QueryDescriptor>>(schedule: Schedule, name: string, descriptor: SystemDescriptor<Qs>): Result<void, ScheduleMutationError>;
+/**
+ * Batch-register systems to a set. Validates the set token before writing.
+ *
+ * - First call for a system name: registers via the existing `addSystem` path.
+ * - Subsequent calls: only adds the system name to the set's members (dedup).
+ * - `runIf` / `chained` are snapshotted from the token into the SetRecord on
+ *   first encounter.
+ *
+ * Returns `Result.err` with `SystemSetNotRegisteredError` if the set token
+ * fails identity validation.
+ */
+export declare function addSystems<const Qs extends ReadonlyArray<QueryDescriptor>>(schedule: Schedule, set: SystemSet, systems: ReadonlyArray<SystemDescriptor<Qs>>): Result<void, SystemSetNotRegisteredError>;
+/**
+ * Build the sorted execution order via Kahn's topological sort.
+ * Throws CyclicDependencyError if a cycle is detected.
+ *
+ * @returns sorted system names
+ */
+export declare function buildSchedule(schedule: Schedule): string[];
+/**
+ * Execute one schedule with a terminalization guard.  Query construction,
+ * run-if evaluation, DAG compilation, and command draining may all throw an
+ * unexpected error; every still-open buffer is nevertheless aborted before the
+ * error reaches World.update.
+ */
+export declare function runSchedule(schedule: Schedule, world: World, selectedNames?: readonly string[], commandsBySystem?: Map<string, import("./commands").CommandBufferImpl>, finalDrain?: boolean): void;
+export {};
+//# sourceMappingURL=schedule.d.ts.map

package/dist/schedule.d.ts.map

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

package/dist/shared-ref-store.d.ts

@@ -0,0 +1,144 @@
+import type { Handle } from '@forgeax/engine-types';
+import { type Result } from '@forgeax/engine-types';
+import { BuiltinSlotNotOwnedError, SharedRefDoubleReleaseError, SharedRefReleasedError, SharedRefStaleError } from './errors';
+export interface SharedRefMutation {
+    readonly epoch: number;
+    readonly handle: number;
+}
+export interface SharedRefReleaseEvidence {
+    readonly payload: unknown;
+    readonly refcount: 0;
+    readonly generation: number;
+    readonly evidence: 'released';
+}
+export type SharedRefMutationRead = {
+    readonly status: 'ok';
+    readonly cursor: number;
+    readonly records: readonly SharedRefMutation[];
+} | {
+    readonly status: 'overflow';
+    readonly cursor: number;
+    readonly oldestAvailable: number;
+};
+/**
+ * Reference-counted store for ECS-aware `Handle<T, 'shared'>` lifecycles.
+ *
+ * The producer (typically AssetRegistry) calls `alloc` once and owns the
+ * "alloc-grant" rc=1; consumers (ECS schema fields, external systems) call
+ * `retain` on each new holder and `release` when the holder drops. When rc
+ * transitions 1 -> 0 the store publishes one structured release-evidence
+ * record; it does not invoke a user callback or own payload disposal.
+ *
+ * D-15: manages ONLY user-tier slots (`slot >= BUILTIN_BASE`). Builtin slots
+ * (`< BUILTIN_BASE`) fail-fast with `BuiltinSlotNotOwnedError`.
+ *
+ * Public API:
+ *   - alloc(target, payload)        -> Handle<T, 'shared'> (rc=1)
+ *   - intern(target, payload)        -> stable producer handle per target + object identity
+ *   - resolve(handle)             -> Result<T, SharedRefReleasedError | SharedRefStaleError | BuiltinSlotNotOwnedError>
+ *   - markChanged(handle)         -> Result<void, SharedRefReleasedError | SharedRefStaleError | BuiltinSlotNotOwnedError>
+ *   - getMutationEpoch()          -> monotonic payload-mutation cursor
+ *   - retain(handle)              -> Result<void, SharedRefReleasedError | SharedRefStaleError | BuiltinSlotNotOwnedError>
+ *   - release(handle)             -> Result<release evidence | undefined, ...>
+ *   - refcount(handle)            -> number (0 == released; debug + tests)
+ *   - _liveCount()                -> live slot count (debug + inspector)
+ */
+export declare class SharedRefStore {
+    private readonly payloads;
+    private readonly refcounts;
+    private readonly freeSlots;
+    private readonly internedByTarget;
+    private readonly internedKeys;
+    private nextSlot;
+    private mutationEpoch;
+    private readonly mutationJournal;
+    private readonly releaseJournal;
+    /**
+     * Generation table indexed by slot (D-6). Each entry tracks the current
+     * generation for the slot — written to during alloc (welded into the
+     * returned handle via pack) and incremented on release (M4).
+     *
+     * @internal
+     */
+    private readonly _generations;
+    /**
+     * Allocate a fresh shared handle for `payload`, branded against `target`.
+     * Refcount starts at 1 (the alloc-grant). Nullish payloads are rejected
+     * before a slot or free-list is touched.
+     *
+     * The returned handle carries a generation tag welded via codec.pack
+     * (D-8, OOS-2): first allocation gen=0 (AC-06), reused slot gen = the
+     * current generation from _generations[slot]. The toShared brand cast
+     * happens internally — external callers no longer construct Handle<...>
+     * directly.
+     *
+     * Minted slots are user-tier (`>= BUILTIN_BASE`); builtin slots are never
+     * produced here (D-15).
+     */
+    alloc<Target extends string, T = unknown>(target: Target, payload: T): Handle<Target, 'shared'>;
+    /**
+     * Return the idempotent producer handle for one object payload in this
+     * store. Identity includes `target`, so the same object branded for two
+     * asset kinds does not alias.
+     *
+     * A cache hit deliberately does not retain: this is one producer grant,
+     * discovered repeatedly by an asset catalogue. Actual holders retain and
+     * release through the ECS write barrier. Callers needing independent
+     * grants or a per-handle deleter must use {@link alloc}.
+     */
+    intern<Target extends string, T extends object>(target: Target, payload: T): Handle<Target, 'shared'>;
+    /**
+     * Look up `payload` by handle. Returns `err(shared-ref-released)` when
+     * the handle's slot has no live payload (rc reached 0, no re-alloc has
+     * filled the slot); `err(builtin-slot-not-owned)` for a builtin slot.
+     *
+     * §contract - mirrors UniqueRefStore: a stale handle whose slot has been
+     * released and re-allocated returns `err(shared-ref-stale)` - the handle's
+     * welded generation no longer matches `_generations[slot]`. The gen check
+     * runs before payload lookup, so stale-by-reuse is caught deterministically.
+     */
+    resolve<Target extends string, T = unknown>(handle: Handle<Target, 'shared'>): Result<T, SharedRefReleasedError | SharedRefStaleError | BuiltinSlotNotOwnedError>;
+    /**
+     * Publish that a live payload was mutated in place. Consumers that retain
+     * projections of shared payload data compare the monotonic epoch and
+     * explicitly refresh instead of rescanning every payload each frame.
+     */
+    markChanged<Target extends string>(handle: Handle<Target, 'shared'>): Result<void, SharedRefReleasedError | SharedRefStaleError | BuiltinSlotNotOwnedError>;
+    /** Current upper bound for explicitly published payload mutations. */
+    getMutationEpoch(): number;
+    /** Read exact changed handles after `cursor`; overflow requires consumer resync. */
+    readChangesSince(cursor: number): SharedRefMutationRead;
+    /**
+     * Increment the refcount of a live shared handle. Returns
+     * `err(shared-ref-released)` when the handle is not live - retain MUST
+     * NOT resurrect a released slot (charter P3 explicit failure; would
+     * defeat the rc=0 -> drop invariant); `err(builtin-slot-not-owned)` for a
+     * builtin slot.
+     */
+    retain<Target extends string>(handle: Handle<Target, 'shared'>): Result<void, SharedRefReleasedError | SharedRefStaleError | BuiltinSlotNotOwnedError>;
+    /**
+     * Decrement the refcount. When rc transitions 1 -> 0, the slot is dropped
+     * and one structured release-evidence record is published. The evidence
+     * captures the payload, zero refcount, next generation and `released` marker
+     * after the store has removed the live slot.
+     *
+     * Returns `err(shared-ref-double-release, rc=0)` when the handle has
+     * already reached rc=0 (or was never live); `err(builtin-slot-not-owned)`
+     * for a builtin slot. AI users branch on `.code` and route the
+     * second-release log to Layer 3 ErrorHandler without aborting the despawn
+     * chain.
+     */
+    release<Target extends string>(handle: Handle<Target, 'shared'>): Result<SharedRefReleaseEvidence | undefined, SharedRefDoubleReleaseError | SharedRefStaleError | BuiltinSlotNotOwnedError>;
+    /** Read the bounded release evidence owned by this store. */
+    readReleaseEvidence(): readonly SharedRefReleaseEvidence[];
+    /**
+     * Return the current refcount for `handle`. Returns 0 for a released
+     * (or never-allocated) slot. Primarily a debug + tests entry point;
+     * production code rarely reads rc directly (the rc=0 -> drop invariant
+     * is the surface AI users consume via release / the per-handle deleter).
+     */
+    refcount<Target extends string>(handle: Handle<Target, 'shared'>): number;
+    /** @internal Diagnostic count of live slots. Exposed for tests + inspector. */
+    _liveCount(): number;
+}
+//# sourceMappingURL=shared-ref-store.d.ts.map

package/dist/shared-ref-store.d.ts.map

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

package/dist/shared.d.ts

@@ -0,0 +1,3 @@
+export type { KernelDispatchFailure, KernelDispatchResult, KernelDispatchSpan, SharedFieldView, SharedKernelDefinition, SharedKernelDispatch, SharedKernelEligibilityReason, SharedKernelExecutor, SharedKernelHandle, SharedSpanBinding, WorldExecutionHealth, } from './execution/shared-kernel';
+export { bindSharedSpan, defineSharedKernel, isKernelDispatchFailure, isSharedSpan, SHARED_KERNEL_ELIGIBILITY_REASONS, SHARED_KERNEL_EXECUTOR_RESOURCE_KEY, sharedKernelEligibility, splitSharedSpan, } from './execution/shared-kernel';
+//# sourceMappingURL=shared.d.ts.map

package/dist/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,qBAAqB,EACrB,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,sBAAsB,EACtB,oBAAoB,EACpB,6BAA6B,EAC7B,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,uBAAuB,EACvB,YAAY,EACZ,iCAAiC,EACjC,mCAAmC,EACnC,uBAAuB,EACvB,eAAe,GAChB,MAAM,2BAA2B,CAAC"}