@videojs/spf 10.0.0-beta.23 → 10.0.0-beta.25

package/dist/dev/core/actors/create-machine-actor.d.ts

@@ -0,0 +1,125 @@
+import { TaskLike } from "../tasks/task.js";
+import { SignalActor } from "./actor.js";
+
+//#region src/core/actors/create-machine-actor.d.ts
+/**
+ * Minimal interface for any runner that can be used with createMachineActor.
+ */
+interface RunnerLike {
+  schedule<Value = void, Err = unknown>(task: TaskLike<Value, Err>): Promise<Value>;
+  abortAll(): void;
+  destroy(): void;
+  whenSettled(callback: () => void): void;
+}
+/**
+ * Context passed to message handlers.
+ * `runner` is present and typed as the exact runner instance only when the
+ * definition includes a runner factory.
+ */
+type HandlerContext<UserState extends string, Context extends object, RunnerFactory extends (() => RunnerLike) | undefined> = {
+  transition: (to: UserState) => void; /** Context snapshot captured at dispatch time. Stale after any `setContext` call. */
+  context: Context;
+  /**
+   * Live untracked read of the current context. Use in async task closures that
+   * execute after the handler returns — e.g. `getCtx: getContext` passed to tasks
+   * scheduled on the runner, so each task reads the context committed by the
+   * previous task rather than the stale snapshot from dispatch time.
+   */
+  getContext: () => Context;
+  setContext: (next: Context) => void;
+} & (RunnerFactory extends (() => infer R) ? {
+  runner: R;
+} : object);
+/**
+ * Definition for a single user-defined state.
+ */
+type ActorStateDefinition<UserState extends string, Context extends object, Message extends {
+  type: string;
+}, RunnerFactory extends (() => RunnerLike) | undefined> = {
+  /**
+   * When the actor's runner settles while in this state, automatically
+   * transition to this state. The framework owns the generation-token logic —
+   * re-registering after each `runner.schedule()` call so that
+   * `abortAll()` + reschedule correctly supersedes stale callbacks.
+   */
+  onSettled?: UserState; /** Message handlers active in this state. Messages with no handler are silently dropped. */
+  on?: { [M in Message as M['type']]?: (message: Extract<Message, {
+    type: M['type'];
+  }>, ctx: HandlerContext<UserState, Context, RunnerFactory>) => void };
+};
+/**
+ * Full actor definition passed to `createMachineActor`.
+ *
+ * `UserState` is the set of domain-meaningful states. `'destroyed'` is always
+ * added by the framework as the implicit terminal state — do not include it here.
+ */
+type ActorDefinition<UserState extends string, Context extends object, Message extends {
+  type: string;
+}, RunnerFactory extends (() => RunnerLike) | undefined = undefined> = {
+  /**
+   * Runner factory — called once at `createMachineActor()` time.
+   * The runner lives for the full actor lifetime and is destroyed with it.
+   *
+   * @example
+   * runner: () => new SerialRunner()
+   */
+  runner?: RunnerFactory; /** Initial state. */
+  initial: UserState; /** Initial context. */
+  context: Context;
+  /**
+   * Per-state definitions. States with no definition silently drop all messages.
+   * All user-defined states must appear as keys in the `UserState` union.
+   */
+  states: Partial<Record<UserState, ActorStateDefinition<UserState, Context, Message, RunnerFactory>>>;
+};
+/** Live actor instance returned by `createMachineActor`. */
+interface MessageActor<State extends string, Context extends object, Message extends {
+  type: string;
+}> extends SignalActor<State, Context> {
+  send(message: Message): void;
+}
+/**
+ * Creates a message-driven actor from a declarative definition.
+ *
+ * The actor owns a reactive snapshot signal (state + context), an optional
+ * runner, and dispatches incoming messages to per-state handlers. `'destroyed'`
+ * is always the implicit terminal state — `destroy()` transitions there
+ * unconditionally and all subsequent `send()` calls are no-ops.
+ *
+ * When a state declares `onSettled`, the framework calls `runner.whenSettled()`
+ * after the handler returns. The runner owns the generation-token logic — if
+ * new tasks are scheduled before the current batch settles, the callback is
+ * automatically superseded.
+ *
+ * @example
+ * const actor = createMachineActor({
+ *   runner: () => new SerialRunner(),
+ *   initial: 'idle',
+ *   context: {},
+ *   states: {
+ *     idle: {
+ *       on: {
+ *         load: (msg, { transition, runner }) => {
+ *           segments.forEach(s => runner.schedule(new Task(...)));
+ *           transition('loading');
+ *         }
+ *       }
+ *     },
+ *     loading: {
+ *       onSettled: 'idle',
+ *       on: {
+ *         load: (msg, { runner }) => {
+ *           runner.abortAll();
+ *           segments.forEach(s => runner.schedule(new Task(...)));
+ *         }
+ *       }
+ *     }
+ *   }
+ * });
+ */
+declare function createMachineActor<UserState extends string, Context extends object, Message extends {
+  type: string;
+}, RunnerFactory extends (() => RunnerLike) | undefined = undefined>(def: ActorDefinition<UserState, Context, Message, RunnerFactory>): MessageActor<UserState | 'destroyed', Context, Message>;
+//#endregion
+export { ActorDefinition, ActorStateDefinition, HandlerContext, MessageActor, RunnerLike, createMachineActor };
+//# sourceMappingURL=create-machine-actor.d.ts.map

package/dist/dev/core/actors/create-machine-actor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-machine-actor.d.ts","names":[],"sources":["../../../../src/core/actors/create-machine-actor.ts"],"mappings":";;;;;;AAYA;UAAiB,UAAA;EACf,QAAA,8BAAsC,IAAA,EAAM,QAAA,CAAS,KAAA,EAAO,GAAA,IAAO,OAAA,CAAQ,KAAA;EAC3E,QAAA;EACA,OAAA;EACA,WAAA,CAAY,QAAA;AAAA;;;;;;KAYF,cAAA,gFAGmB,UAAA;EAE7B,UAAA,GAAa,EAAA,EAAI,SAAA,WApBoC;EAsBrD,OAAA,EAAS,OAAA;EAtB6B;;;;;;EA6BtC,UAAA,QAAkB,OAAA;EAClB,UAAA,GAAa,IAAA,EAAM,OAAA;AAAA,KAChB,aAAA;EAAwC,MAAA,EAAQ,CAAA;AAAA;;;;KAKzC,oBAAA;EAGQ,IAAA;AAAA,gCACW,UAAA;EAT1B;;;;;;EAiBH,SAAA,GAAY,SAAA,EA9BiB;EAgC7B,EAAA,WACQ,OAAA,IAAW,CAAA,aACf,OAAA,EAAS,OAAA,CAAQ,OAAA;IAAW,IAAA,EAAM,CAAA;EAAA,IAClC,GAAA,EAAK,cAAA,CAAe,SAAA,EAAW,OAAA,EAAS,aAAA;AAAA;;;;;;;KAWlC,eAAA;EAGQ,IAAA;AAAA,gCACW,UAAA;EArCuB;AAKtD;;;;;;EAyCE,MAAA,GAAS,aAAA,EAzBY;EA2BrB,OAAA,EAAS,SAAA,EA3BI;EA6Bb,OAAA,EAAS,OAAA;EA5B0B;;;;EAiCnC,MAAA,EAAQ,OAAA,CAAQ,MAAA,CAAO,SAAA,EAAW,oBAAA,CAAqB,SAAA,EAAW,OAAA,EAAS,OAAA,EAAS,aAAA;AAAA;;UAQrE,YAAA;EAA6E,IAAA;AAAA,WACpF,WAAA,CAAY,KAAA,EAAO,OAAA;EAC3B,IAAA,CAAK,OAAA,EAAS,OAAA;AAAA;;;;;;;;;;;;;;;;;;AAhChB;;;;;;;;;;;;;;;;;;;;;;iBA8EgB,kBAAA;EAGI,IAAA;AAAA,gCACW,UAAA,0BAAA,CAE7B,GAAA,EAAK,eAAA,CAAgB,SAAA,EAAW,OAAA,EAAS,OAAA,EAAS,aAAA,IACjD,YAAA,CAAa,SAAA,gBAAyB,OAAA,EAAS,OAAA"}

package/dist/{default/core → dev/core/actors}/create-machine-actor.js

@@ -1,6 +1,6 @@
-import { untrack, update } from "./signals/primitives.js";
-import { createMachineCore } from "./machine.js";
-//#region src/core/create-machine-actor.ts
+import { untrack, update } from "../signals/primitives.js";
+import { createMachineCore } from "../machine.js";
+//#region src/core/actors/create-machine-actor.ts
 /**
 * Creates a message-driven actor from a declarative definition.
 *

package/dist/dev/core/actors/create-machine-actor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-machine-actor.js","names":[],"sources":["../../../../src/core/actors/create-machine-actor.ts"],"sourcesContent":["import { createMachineCore } from '../machine';\nimport { untrack, update } from '../signals/primitives';\nimport type { TaskLike } from '../tasks/task';\nimport type { ActorSnapshot, SignalActor } from './actor';\n\n// =============================================================================\n// Runner interfaces\n// =============================================================================\n\n/**\n * Minimal interface for any runner that can be used with createMachineActor.\n */\nexport interface RunnerLike {\n  schedule<Value = void, Err = unknown>(task: TaskLike<Value, Err>): Promise<Value>;\n  abortAll(): void;\n  destroy(): void;\n  whenSettled(callback: () => void): void;\n}\n\n// =============================================================================\n// Definition types\n// =============================================================================\n\n/**\n * Context passed to message handlers.\n * `runner` is present and typed as the exact runner instance only when the\n * definition includes a runner factory.\n */\nexport type HandlerContext<\n  UserState extends string,\n  Context extends object,\n  RunnerFactory extends (() => RunnerLike) | undefined,\n> = {\n  transition: (to: UserState) => void;\n  /** Context snapshot captured at dispatch time. Stale after any `setContext` call. */\n  context: Context;\n  /**\n   * Live untracked read of the current context. Use in async task closures that\n   * execute after the handler returns — e.g. `getCtx: getContext` passed to tasks\n   * scheduled on the runner, so each task reads the context committed by the\n   * previous task rather than the stale snapshot from dispatch time.\n   */\n  getContext: () => Context;\n  setContext: (next: Context) => void;\n} & (RunnerFactory extends () => infer R ? { runner: R } : object);\n\n/**\n * Definition for a single user-defined state.\n */\nexport type ActorStateDefinition<\n  UserState extends string,\n  Context extends object,\n  Message extends { type: string },\n  RunnerFactory extends (() => RunnerLike) | undefined,\n> = {\n  /**\n   * When the actor's runner settles while in this state, automatically\n   * transition to this state. The framework owns the generation-token logic —\n   * re-registering after each `runner.schedule()` call so that\n   * `abortAll()` + reschedule correctly supersedes stale callbacks.\n   */\n  onSettled?: UserState;\n  /** Message handlers active in this state. Messages with no handler are silently dropped. */\n  on?: {\n    [M in Message as M['type']]?: (\n      message: Extract<Message, { type: M['type'] }>,\n      ctx: HandlerContext<UserState, Context, RunnerFactory>\n    ) => void;\n  };\n};\n\n/**\n * Full actor definition passed to `createMachineActor`.\n *\n * `UserState` is the set of domain-meaningful states. `'destroyed'` is always\n * added by the framework as the implicit terminal state — do not include it here.\n */\nexport type ActorDefinition<\n  UserState extends string,\n  Context extends object,\n  Message extends { type: string },\n  RunnerFactory extends (() => RunnerLike) | undefined = undefined,\n> = {\n  /**\n   * Runner factory — called once at `createMachineActor()` time.\n   * The runner lives for the full actor lifetime and is destroyed with it.\n   *\n   * @example\n   * runner: () => new SerialRunner()\n   */\n  runner?: RunnerFactory;\n  /** Initial state. */\n  initial: UserState;\n  /** Initial context. */\n  context: Context;\n  /**\n   * Per-state definitions. States with no definition silently drop all messages.\n   * All user-defined states must appear as keys in the `UserState` union.\n   */\n  states: Partial<Record<UserState, ActorStateDefinition<UserState, Context, Message, RunnerFactory>>>;\n};\n\n// =============================================================================\n// Live actor interface\n// =============================================================================\n\n/** Live actor instance returned by `createMachineActor`. */\nexport interface MessageActor<State extends string, Context extends object, Message extends { type: string }>\n  extends SignalActor<State, Context> {\n  send(message: Message): void;\n}\n\n// =============================================================================\n// Implementation\n// =============================================================================\n\n/**\n * Creates a message-driven actor from a declarative definition.\n *\n * The actor owns a reactive snapshot signal (state + context), an optional\n * runner, and dispatches incoming messages to per-state handlers. `'destroyed'`\n * is always the implicit terminal state — `destroy()` transitions there\n * unconditionally and all subsequent `send()` calls are no-ops.\n *\n * When a state declares `onSettled`, the framework calls `runner.whenSettled()`\n * after the handler returns. The runner owns the generation-token logic — if\n * new tasks are scheduled before the current batch settles, the callback is\n * automatically superseded.\n *\n * @example\n * const actor = createMachineActor({\n *   runner: () => new SerialRunner(),\n *   initial: 'idle',\n *   context: {},\n *   states: {\n *     idle: {\n *       on: {\n *         load: (msg, { transition, runner }) => {\n *           segments.forEach(s => runner.schedule(new Task(...)));\n *           transition('loading');\n *         }\n *       }\n *     },\n *     loading: {\n *       onSettled: 'idle',\n *       on: {\n *         load: (msg, { runner }) => {\n *           runner.abortAll();\n *           segments.forEach(s => runner.schedule(new Task(...)));\n *         }\n *       }\n *     }\n *   }\n * });\n */\nexport function createMachineActor<\n  UserState extends string,\n  Context extends object,\n  Message extends { type: string },\n  RunnerFactory extends (() => RunnerLike) | undefined = undefined,\n>(\n  def: ActorDefinition<UserState, Context, Message, RunnerFactory>\n): MessageActor<UserState | 'destroyed', Context, Message> {\n  type FullState = UserState | 'destroyed';\n\n  const runner = def.runner?.() as RunnerLike | undefined;\n  const { snapshotSignal, getState, transition } = createMachineCore<FullState, ActorSnapshot<FullState, Context>>({\n    value: def.initial as FullState,\n    context: def.context,\n  });\n\n  const getContext = (): Context => untrack(() => snapshotSignal.get().context);\n\n  const setContext = (context: Context): void => {\n    update(snapshotSignal, { context });\n  };\n\n  return {\n    get snapshot() {\n      return snapshotSignal;\n    },\n\n    send(message: Message): void {\n      const state = getState();\n      if (state === 'destroyed') return;\n      const stateDef = def.states[state as UserState];\n      const handler = stateDef?.on?.[message.type as keyof typeof stateDef.on] as\n        | ((msg: Message, ctx: HandlerContext<UserState, Context, RunnerFactory>) => void)\n        | undefined;\n      if (!handler) return;\n      handler(message, {\n        context: getContext(),\n        getContext,\n        transition: (to: UserState) => transition(to as FullState),\n        setContext,\n        ...(runner ? { runner } : {}),\n      } as HandlerContext<UserState, Context, RunnerFactory>);\n      // Register onSettled after the handler so we read the post-transition state.\n      const newState = getState();\n      if (newState !== 'destroyed') {\n        const newStateDef = def.states[newState as UserState];\n        if (newStateDef?.onSettled && runner) {\n          const targetState = newStateDef.onSettled as FullState;\n          runner.whenSettled(() => {\n            if (getState() !== newState) return;\n            transition(targetState);\n          });\n        }\n      }\n    },\n\n    destroy(): void {\n      if (getState() === 'destroyed') return;\n      runner?.destroy();\n      transition('destroyed');\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2JA,SAAgB,mBAMd,KACyD;CAGzD,MAAM,SAAS,IAAI,UAAU;CAC7B,MAAM,EAAE,gBAAgB,UAAU,eAAe,kBAAgE;EAC/G,OAAO,IAAI;EACX,SAAS,IAAI;EACd,CAAC;CAEF,MAAM,mBAA4B,cAAc,eAAe,KAAK,CAAC,QAAQ;CAE7E,MAAM,cAAc,YAA2B;AAC7C,SAAO,gBAAgB,EAAE,SAAS,CAAC;;AAGrC,QAAO;EACL,IAAI,WAAW;AACb,UAAO;;EAGT,KAAK,SAAwB;GAC3B,MAAM,QAAQ,UAAU;AACxB,OAAI,UAAU,YAAa;GAE3B,MAAM,UADW,IAAI,OAAO,QACF,KAAK,QAAQ;AAGvC,OAAI,CAAC,QAAS;AACd,WAAQ,SAAS;IACf,SAAS,YAAY;IACrB;IACA,aAAa,OAAkB,WAAW,GAAgB;IAC1D;IACA,GAAI,SAAS,EAAE,QAAQ,GAAG,EAAE;IAC7B,CAAsD;GAEvD,MAAM,WAAW,UAAU;AAC3B,OAAI,aAAa,aAAa;IAC5B,MAAM,cAAc,IAAI,OAAO;AAC/B,QAAI,aAAa,aAAa,QAAQ;KACpC,MAAM,cAAc,YAAY;AAChC,YAAO,kBAAkB;AACvB,UAAI,UAAU,KAAK,SAAU;AAC7B,iBAAW,YAAY;OACvB;;;;EAKR,UAAgB;AACd,OAAI,UAAU,KAAK,YAAa;AAChC,WAAQ,SAAS;AACjB,cAAW,YAAY;;EAE1B"}

package/dist/dev/core/actors/create-transition-actor.d.ts

@@ -0,0 +1,42 @@
+import { ActorSnapshot } from "./actor.js";
+import { Machine } from "../machine.js";
+
+//#region src/core/actors/create-transition-actor.d.ts
+/**
+ * A reducer-shaped actor: `(context, message) => context`.
+ *
+ * No finite states — the snapshot carries `value: 'active' | 'destroyed'`
+ * as a universal lifecycle marker rather than domain state. The interesting
+ * state is entirely in the context, which is reactive via `snapshot`.
+ *
+ * Use this when the actor has context that needs to be reactive but no
+ * meaningful state machine (e.g., a message-driven model with DOM side
+ * effects). For actors that need per-state behavior, use `createMachineActor`.
+ */
+interface TransitionActor<Context extends object, Message extends {
+  type: string;
+}> extends Machine<ActorSnapshot<'active' | 'destroyed', Context>> {
+  send(message: Message): void;
+}
+/**
+ * Creates a reducer-shaped actor from an initial context and a reducer function.
+ *
+ * The reducer receives the current context and a message and returns the next
+ * context. Returning the same reference (by identity) skips the signal update —
+ * so early-returning `context` unchanged is both the no-op and the optimization.
+ *
+ * Side effects (e.g. DOM mutations) may be performed inside the reducer.
+ * They run synchronously before the signal is updated.
+ *
+ * @example
+ * const actor = createTransitionActor(
+ *   { count: 0 },
+ *   (context, message: { type: 'increment' }) => ({ count: context.count + 1 })
+ * );
+ */
+declare function createTransitionActor<Context extends object, Message extends {
+  type: string;
+}>(initialContext: Context, reducer: (context: Context, message: Message) => Context): TransitionActor<Context, Message>;
+//#endregion
+export { TransitionActor, createTransitionActor };
+//# sourceMappingURL=create-transition-actor.d.ts.map

package/dist/dev/core/actors/create-transition-actor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-transition-actor.d.ts","names":[],"sources":["../../../../src/core/actors/create-transition-actor.ts"],"mappings":";;;;;;AAoBA;;;;;;;;;UAAiB,eAAA;EAA0D,IAAA;AAAA,WACjE,OAAA,CAAQ,aAAA,yBAAsC,OAAA;EACtD,IAAA,CAAK,OAAA,EAAS,OAAA;AAAA;;;;;;;AAuBhB;;;;;;;;;;iBAAgB,qBAAA;EAAgE,IAAA;AAAA,EAAA,CAC9E,cAAA,EAAgB,OAAA,EAChB,OAAA,GAAU,OAAA,EAAS,OAAA,EAAS,OAAA,EAAS,OAAA,KAAY,OAAA,GAChD,eAAA,CAAgB,OAAA,EAAS,OAAA"}

package/dist/dev/core/{create-transition-actor.js → actors/create-transition-actor.js}

@@ -1,6 +1,6 @@
-import { untrack, update } from "./signals/primitives.js";
-import { createMachineCore } from "./machine.js";
-//#region src/core/create-transition-actor.ts
+import { untrack, update } from "../signals/primitives.js";
+import { createMachineCore } from "../machine.js";
+//#region src/core/actors/create-transition-actor.ts
 /**
 * Creates a reducer-shaped actor from an initial context and a reducer function.
 *

package/dist/dev/core/actors/create-transition-actor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-transition-actor.js","names":[],"sources":["../../../../src/core/actors/create-transition-actor.ts"],"sourcesContent":["import type { Machine } from '../machine';\nimport { createMachineCore } from '../machine';\nimport { untrack, update } from '../signals/primitives';\nimport type { ActorSnapshot } from './actor';\n\n// =============================================================================\n// Definition types\n// =============================================================================\n\n/**\n * A reducer-shaped actor: `(context, message) => context`.\n *\n * No finite states — the snapshot carries `value: 'active' | 'destroyed'`\n * as a universal lifecycle marker rather than domain state. The interesting\n * state is entirely in the context, which is reactive via `snapshot`.\n *\n * Use this when the actor has context that needs to be reactive but no\n * meaningful state machine (e.g., a message-driven model with DOM side\n * effects). For actors that need per-state behavior, use `createMachineActor`.\n */\nexport interface TransitionActor<Context extends object, Message extends { type: string }>\n  extends Machine<ActorSnapshot<'active' | 'destroyed', Context>> {\n  send(message: Message): void;\n}\n\n// =============================================================================\n// Implementation\n// =============================================================================\n\n/**\n * Creates a reducer-shaped actor from an initial context and a reducer function.\n *\n * The reducer receives the current context and a message and returns the next\n * context. Returning the same reference (by identity) skips the signal update —\n * so early-returning `context` unchanged is both the no-op and the optimization.\n *\n * Side effects (e.g. DOM mutations) may be performed inside the reducer.\n * They run synchronously before the signal is updated.\n *\n * @example\n * const actor = createTransitionActor(\n *   { count: 0 },\n *   (context, message: { type: 'increment' }) => ({ count: context.count + 1 })\n * );\n */\nexport function createTransitionActor<Context extends object, Message extends { type: string }>(\n  initialContext: Context,\n  reducer: (context: Context, message: Message) => Context\n): TransitionActor<Context, Message> {\n  const { snapshotSignal, getState, transition } = createMachineCore<\n    'active' | 'destroyed',\n    ActorSnapshot<'active' | 'destroyed', Context>\n  >({ value: 'active', context: initialContext });\n\n  const getContext = (): Context => untrack(() => snapshotSignal.get().context);\n  const setContext = (context: Context): void => update(snapshotSignal, { context });\n\n  return {\n    get snapshot() {\n      return snapshotSignal;\n    },\n\n    send(message: Message): void {\n      if (getState() === 'destroyed') return;\n      const context = getContext();\n      const newContext = reducer(context, message);\n      if (newContext !== context) setContext(newContext);\n    },\n\n    destroy(): void {\n      if (getState() === 'destroyed') return;\n      transition('destroyed');\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,sBACd,gBACA,SACmC;CACnC,MAAM,EAAE,gBAAgB,UAAU,eAAe,kBAG/C;EAAE,OAAO;EAAU,SAAS;EAAgB,CAAC;CAE/C,MAAM,mBAA4B,cAAc,eAAe,KAAK,CAAC,QAAQ;CAC7E,MAAM,cAAc,YAA2B,OAAO,gBAAgB,EAAE,SAAS,CAAC;AAElF,QAAO;EACL,IAAI,WAAW;AACb,UAAO;;EAGT,KAAK,SAAwB;AAC3B,OAAI,UAAU,KAAK,YAAa;GAChC,MAAM,UAAU,YAAY;GAC5B,MAAM,aAAa,QAAQ,SAAS,QAAQ;AAC5C,OAAI,eAAe,QAAS,YAAW,WAAW;;EAGpD,UAAgB;AACd,OAAI,UAAU,KAAK,YAAa;AAChC,cAAW,YAAY;;EAE1B"}

package/dist/dev/core/composition/create-composition.d.ts

@@ -0,0 +1,274 @@
+import { ReadonlySignal, Signal } from "../signals/primitives.js";
+
+//#region src/core/composition/create-composition.d.ts
+/**
+ * Cleanup returned by a behavior. Behaviors may return:
+ * - `void` / `undefined` — no cleanup needed
+ * - A function — called on destroy (may return a Promise)
+ * - An object with `destroy()` — called on destroy (may return a Promise)
+ */
+type BehaviorCleanup = void | (() => void | Promise<void>) | {
+  destroy(): void | Promise<void>;
+};
+/**
+ * A signal map keyed by the fields of `S`. Each field is a writable signal.
+ *
+ * Optional fields on `S` map to required signal slots whose value type
+ * includes `undefined`, ensuring every key has a signal even when the
+ * underlying value is absent.
+ *
+ * Used in two roles:
+ * - Engine-side **construction**: `Composition<S, C>` exposes its public
+ *   surface as `StateSignals<S>` (everything writable) so external code
+ *   can read or write any slot.
+ * - Behavior **input convenience**: a behavior that writes to every slot
+ *   can type its setup state param as `StateSignals<{ ... }>` rather than
+ *   spelling out per-slot `Signal<T>` types.
+ *
+ * Behaviors that mix read-only and writable slots type the setup param
+ * directly as a slot map (`{ x: Signal<T>; y: ReadonlySignal<U> }`)
+ * instead of going through `StateSignals<>`.
+ */
+type StateSignals<S extends object> = { [K in keyof S]-?: Signal<S[K]> };
+/**
+ * A signal map keyed by the fields of `C`. Each field is a writable signal
+ * for a platform object or actor reference. Same dual role as
+ * `StateSignals<S>` — see its docblock.
+ */
+type ContextSignals<C extends object> = { [K in keyof C]-?: Signal<C[K]> };
+/**
+ * Slot-map shape — a record where each value is at least a `ReadonlySignal`.
+ * `Signal<T>` is structurally a subtype of `ReadonlySignal<T>` (it adds
+ * `.set()`), so a writable slot satisfies this bound too.
+ *
+ * This is the bound used for behavior `state` / `context` slot maps. It
+ * lets a single behavior declare a *heterogeneous* slot map where some
+ * slots are `Signal<T>` (writable) and others are `ReadonlySignal<T>`
+ * (read-only) — making read/write intent explicit at the call site and
+ * giving body-level enforcement (TS rejects `.set()` on a read-only slot).
+ */
+type AnySlotMap = Record<PropertyKey, ReadonlySignal<unknown>>;
+/**
+ * The deps object passed to each behavior by the composition.
+ *
+ * - `state` — slot map for state fields (reactive data). Per-slot read/
+ *   write intent expressed via `Signal<T>` vs `ReadonlySignal<T>`.
+ * - `context` — slot map for platform objects and actor references.
+ * - `config` — static configuration, passed once at composition creation.
+ */
+interface BehaviorDeps<StateMap extends AnySlotMap, ContextMap extends AnySlotMap, Cfg extends object> {
+  state: StateMap;
+  context: ContextMap;
+  config: Cfg;
+}
+/**
+ * A behavior announces the state and context keys it needs alongside a
+ * `setup` function that receives deps (state, context, config) and
+ * returns an optional cleanup handle.
+ *
+ * The `stateKeys` / `contextKeys` declarations are the runtime expression
+ * of the behavior's contract — the caller (e.g. `createComposition`) uses
+ * them to know which signals to provide. The setup parameter type
+ * declares the *slot map* (per-slot `Signal<T>` vs `ReadonlySignal<T>`);
+ * together they form a complete contract.
+ *
+ * Manual `Behavior<>` literals (e.g. engine wrappers that forward keys
+ * from a wrapped behavior, or pass-through behaviors like `shareSignals`)
+ * opt out of exhaustiveness — the type alias is permissive (subset).
+ * Source behaviors should use `defineBehavior` to get exhaustiveness
+ * enforcement at the call site.
+ */
+interface Behavior<StateMap extends AnySlotMap = Empty, ContextMap extends AnySlotMap = Empty, Cfg extends object = Empty> {
+  /** State keys this behavior reads/writes. Subset of `keyof StateMap`. */
+  stateKeys: readonly (keyof StateMap)[];
+  /** Context keys this behavior reads/writes. Subset of `keyof ContextMap`. */
+  contextKeys: readonly (keyof ContextMap)[];
+  setup: (deps: BehaviorDeps<StateMap, ContextMap, Cfg>) => BehaviorCleanup;
+}
+/** A behavior with an unconstrained setup — used as a generic bound. */
+type AnyBehavior = {
+  stateKeys: readonly PropertyKey[];
+  contextKeys: readonly PropertyKey[];
+  setup: (deps: any) => BehaviorCleanup;
+};
+/** Extract the deps type from a behavior's setup function. */
+type DepsOf<B> = B extends {
+  setup: (deps: infer D, ...args: any[]) => any;
+} ? D : never;
+/**
+ * Empty-object fallback used when a behavior omits state, context, or config.
+ *
+ * Using `{}` rather than `object` is deliberate — `object & {x: T}` collapses
+ * to `{x: never}` under TS's union-to-intersection conversion in some inference
+ * contexts (likely a TS quirk around the `object` upper bound), whereas
+ * `{} & {x: T}` simplifies cleanly to `{x: T}`.
+ */
+type Empty = {};
+/**
+ * Unwrap a signal map back to its state/context shape.
+ *
+ * Inferring through `{ get(): infer V }` rather than `Signal<infer V>`
+ * sidesteps `Signal`'s nominal/invariance behaviour — the conditional
+ * matches structurally on the read side, and `V` is inferred covariantly.
+ */
+type UnwrapSignals<M> = M extends object ? { [K in keyof M]: M[K] extends {
+  get(): infer V;
+} ? V : never } : Empty;
+/** Infer the state shape a behavior requires from its deps parameter. */
+type InferBehaviorState<F> = DepsOf<F> extends {
+  state: infer M;
+} ? UnwrapSignals<M> : Empty;
+/** Infer the context shape a behavior requires from its deps parameter. */
+type InferBehaviorContext<F> = DepsOf<F> extends {
+  context: infer M;
+} ? UnwrapSignals<M> : Empty;
+/** Infer the config shape a behavior requires from its deps parameter. */
+type InferBehaviorConfig<F> = DepsOf<F> extends {
+  config: infer C extends object;
+} ? C : Empty;
+/**
+ * Recursively intersect a per-behavior projection across the tuple.
+ *
+ * Iterating over the tuple directly avoids `UnionToIntersection`'s
+ * function-contravariance trick, which produces unstable intersections
+ * (collapsing concrete fields to `never` or unrelated types) when one of the
+ * union members is the empty `{}` fallback.
+ */
+type IntersectBehaviors<Behaviors extends readonly AnyBehavior[], Project extends object> = Behaviors extends readonly [infer First extends AnyBehavior, ...infer Rest extends readonly AnyBehavior[]] ? Apply<Project, First> & IntersectBehaviors<Rest, Project> : Empty;
+/**
+ * Apply a projection (one of the marker types below) to a single behavior.
+ * Encoded as a discriminated dispatch so the recursion above can stay generic
+ * and we don't have to write three near-identical recursive types.
+ */
+type Apply<Project extends object, F> = Project extends {
+  kind: 'state';
+} ? InferBehaviorState<F> : Project extends {
+  kind: 'context';
+} ? InferBehaviorContext<F> : Project extends {
+  kind: 'config';
+} ? InferBehaviorConfig<F> : never;
+type StateProjection = {
+  kind: 'state';
+};
+type ContextProjection = {
+  kind: 'context';
+};
+type ConfigProjection = {
+  kind: 'config';
+};
+/** Resolve the combined state shape from an array of behaviors (intersection of all requirements). */
+type ResolveBehaviorState<Behaviors extends readonly AnyBehavior[]> = IntersectBehaviors<Behaviors, StateProjection> extends infer R extends object ? R : Empty;
+/** Resolve the combined context shape from an array of behaviors (intersection of all requirements). */
+type ResolveBehaviorContext<Behaviors extends readonly AnyBehavior[]> = IntersectBehaviors<Behaviors, ContextProjection> extends infer R extends object ? R : Empty;
+/** Resolve the combined config shape from an array of behaviors (intersection of all requirements). */
+type ResolveBehaviorConfig<Behaviors extends readonly AnyBehavior[]> = IntersectBehaviors<Behaviors, ConfigProjection> extends infer R extends object ? R : Empty;
+/**
+ * True if any property in `T` collapsed to `undefined` or `never` — indicating
+ * a type conflict from intersecting incompatible behavior requirements.
+ *
+ * - Required conflicts: `{ v: number } & { v: string }` → `{ v: never }` — caught via `[never] extends [undefined]`
+ * - Optional conflicts: `{ v?: number } & { v?: string }` → `{ v?: undefined }` — caught directly
+ */
+type HasConflict<T extends object> = true extends { [K in keyof T]: [T[K]] extends [undefined] ? true : never }[keyof T] ? true : false;
+/**
+ * Validate that a behavior composition has no type conflicts.
+ * Returns the behaviors tuple if valid, or an error message type if conflicts are detected.
+ *
+ * State, context, and config are all checked the same way — by intersecting
+ * each behavior's requirement and looking for collapsed fields. The
+ * intersection-based check applies the same rule to context as to state, so
+ * two behaviors that disagree on a context field's type (e.g. `Surface` vs
+ * `VideoSurface`) surface a conflict at compose time. The prior subtype-based
+ * approach for owners is gone — the unified rule is simpler and catches the
+ * cases where two behaviors silently agreed on a wider supertype.
+ */
+type ValidateComposition<Behaviors extends readonly AnyBehavior[]> = HasConflict<ResolveBehaviorState<Behaviors>> extends true ? 'Error: behaviors have conflicting state types' : HasConflict<ResolveBehaviorContext<Behaviors>> extends true ? 'Error: behaviors have conflicting context types' : HasConflict<ResolveBehaviorConfig<Behaviors>> extends true ? 'Error: behaviors have conflicting config types' : [...Behaviors];
+/**
+ * A composition of behaviors with shared state and context signal maps.
+ */
+interface Composition<S extends object, C extends object> {
+  state: StateSignals<S>;
+  context: ContextSignals<C>;
+  destroy(): Promise<void>;
+}
+/**
+ * Options for `createComposition`.
+ *
+ * Composition derives the state and context signal maps from each
+ * behavior's declared `stateKeys` / `contextKeys`; `initialState` and
+ * `initialContext` seed those signals at creation time. Any unseeded
+ * signal starts as `undefined`.
+ */
+interface CompositionOptions<S extends object, C extends object, Cfg extends object> {
+  /** Static configuration passed to every behavior. */
+  config?: Cfg;
+  /** Initial values for state signals — any subset of `keyof S`. */
+  initialState?: Partial<S>;
+  /** Initial values for context signals — any subset of `keyof C`. */
+  initialContext?: Partial<C>;
+}
+declare function createComposition<const Behaviors extends readonly AnyBehavior[]>(behaviors: ValidateComposition<Behaviors>, options?: CompositionOptions<ResolveBehaviorState<Behaviors>, ResolveBehaviorContext<Behaviors>, ResolveBehaviorConfig<Behaviors>>): Composition<ResolveBehaviorState<Behaviors>, ResolveBehaviorContext<Behaviors>>;
+/**
+ * Compose-time exhaustiveness check.
+ *
+ * Adds a phantom error tag to the parameter shape when `Keys` does not
+ * cover every key in `Slot`. The user's value won't satisfy the phantom
+ * field requirement, so TS surfaces the failure at the call site with a
+ * descriptive message. When exhaustive, the tag is `Empty` and adds no
+ * constraint.
+ */
+type ExhaustiveKeys<Keys extends readonly PropertyKey[], Slot extends object, Name extends string> = [keyof Slot] extends [Keys[number]] ? Empty : { [K in `Error: ${Name}Keys must list every key in the typed slice`]: Exclude<keyof Slot, Keys[number]> };
+/**
+ * Typed factory for behaviors that enforces single-behavior key/param
+ * consistency: declared `stateKeys` must equal `keyof S` (where `S` is
+ * inferred from the setup's `state` parameter type), and same for
+ * `contextKeys` / `C`.
+ *
+ * The `const` modifier on `SK` / `CK` captures literal tuples so e.g.
+ * `stateKeys: ['preload']` infers as `readonly ['preload']`, no `as
+ * const` needed at the call site.
+ *
+ * Cross-behavior consistency at `createComposition` is unchanged — the
+ * existing `IntersectBehaviors` machinery still runs over each
+ * behavior's setup param type.
+ *
+ * @example
+ * ```ts
+ * export const syncPreload = defineBehavior({
+ *   stateKeys: ['preload'],
+ *   contextKeys: ['mediaElement'],
+ *   setup: ({ state, context }: {
+ *     state: StateSignals<{ preload?: 'auto' | 'metadata' | 'none' }>;
+ *     context: ContextSignals<{ mediaElement?: HTMLMediaElement | undefined }>;
+ *   }) => { ... },
+ * });
+ * ```
+ */
+/**
+ * Deps shape for a behavior whose deps slot is empty (no keys). When a
+ * slot is empty, the corresponding deps field is optional — callers
+ * (typically tests) can omit it, and it defaults to `{}` at runtime via
+ * `createComposition`.
+ *
+ * When a slot has at least one key, the behavior reads `state.foo` /
+ * `context.bar` / `config.baz` and we need the field to be required so
+ * the access is type-safe.
+ */
+type RequireIfNonEmpty<Key extends string, T extends object> = keyof T extends never ? { [K in Key]?: T } : { [K in Key]: T };
+type DepsForCfg<StateMap extends AnySlotMap, ContextMap extends AnySlotMap, Cfg extends object> = RequireIfNonEmpty<'state', StateMap> & RequireIfNonEmpty<'context', ContextMap> & RequireIfNonEmpty<'config', Cfg>;
+declare function defineBehavior<StateMap extends AnySlotMap = Empty, ContextMap extends AnySlotMap = Empty, Cfg extends object = Empty, const SK extends readonly (keyof StateMap)[] = readonly [], const CK extends readonly (keyof ContextMap)[] = readonly [], R extends BehaviorCleanup = BehaviorCleanup>(behavior: {
+  stateKeys: SK;
+  contextKeys: CK;
+  setup: (deps: {
+    state: StateMap;
+    context: ContextMap;
+    config: Cfg;
+  }) => R;
+} & ExhaustiveKeys<SK, StateMap, 'state'> & ExhaustiveKeys<CK, ContextMap, 'context'>): {
+  stateKeys: SK;
+  contextKeys: CK;
+  setup: (deps: DepsForCfg<StateMap, ContextMap, Cfg>) => R;
+};
+//#endregion
+export { Behavior, BehaviorCleanup, BehaviorDeps, Composition, CompositionOptions, ContextSignals, InferBehaviorConfig, InferBehaviorContext, InferBehaviorState, ResolveBehaviorConfig, ResolveBehaviorContext, ResolveBehaviorState, StateSignals, createComposition, defineBehavior };
+//# sourceMappingURL=create-composition.d.ts.map

package/dist/dev/core/composition/create-composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-composition.d.ts","names":[],"sources":["../../../../src/core/composition/create-composition.ts"],"mappings":";;;;;AAQA;;;;KAAY,eAAA,wBAAuC,OAAA;EAAmB,OAAA,WAAkB,OAAA;AAAA;;;AAqBxF;;;;;;;;;;;;;;;;;KAAY,YAAA,mCAA+C,CAAA,KAAM,MAAA,CAAO,CAAA,CAAE,CAAA;;;;;;KAO9D,cAAA,mCAAiD,CAAA,KAAM,MAAA,CAAO,CAAA,CAAE,CAAA;;;;;;;AAa5E;;;;;KAAY,UAAA,GAAa,MAAA,CAAO,WAAA,EAAa,cAAA;;;;;;;;AAU7C;UAAiB,YAAA,kBAA8B,UAAA,qBAA+B,UAAA;EAC5E,KAAA,EAAO,QAAA;EACP,OAAA,EAAS,UAAA;EACT,MAAA,EAAQ,GAAA;AAAA;;;;;;;;;;;;;;;;;;UAoBO,QAAA,kBACE,UAAA,GAAa,KAAA,qBACX,UAAA,GAAa,KAAA,uBACX,KAAA;EAHE;EAMvB,SAAA,kBAA2B,QAAA;EALV;EAOjB,WAAA,kBAA6B,UAAA;EAC7B,KAAA,GAAQ,IAAA,EAAM,YAAA,CAAa,QAAA,EAAU,UAAA,EAAY,GAAA,MAAS,eAAA;AAAA;;KAQvD,WAAA;EACH,SAAA,WAAoB,WAAA;EACpB,WAAA,WAAsB,WAAA;EACtB,KAAA,GAAQ,IAAA,UAAc,eAAA;AAAA;;KAInB,MAAA,MAAY,CAAA;EAAY,KAAA,GAAQ,IAAA,cAAkB,IAAA;AAAA,IAAwB,CAAA;;;;;;;;;KAW1E,KAAA;;;;;;;;KASA,aAAA,MAAmB,CAAA,gCAAiC,CAAA,GAAI,CAAA,CAAE,CAAA;EAAa,GAAA;AAAA,IAAmB,CAAA,aAAc,KAAA;AAlC5G;AAAA,KAqCW,kBAAA,MAAwB,MAAA,CAAO,CAAA;EAAa,KAAA;AAAA,IAAmB,aAAA,CAAc,CAAA,IAAK,KAAA;;KAGlF,oBAAA,MAA0B,MAAA,CAAO,CAAA;EAAa,OAAA;AAAA,IAAqB,aAAA,CAAc,CAAA,IAAK,KAAA;;KAGtF,mBAAA,MAAyB,MAAA,CAAO,CAAA;EAAa,MAAA;AAAA,IAAmC,CAAA,GAAI,KAAA;;;;;;AAjCzD;;;KA2ClC,kBAAA,4BAA8C,WAAA,8BAAyC,SAAA,uCACtE,WAAA,iCACW,WAAA,MAE7B,KAAA,CAAM,OAAA,EAAS,KAAA,IAAS,kBAAA,CAAmB,IAAA,EAAM,OAAA,IACjD,KAAA;;;;;;KAOC,KAAA,8BAAmC,OAAA;EAAkB,IAAA;AAAA,IACtD,kBAAA,CAAmB,CAAA,IACnB,OAAA;EAAkB,IAAA;AAAA,IAChB,oBAAA,CAAqB,CAAA,IACrB,OAAA;EAAkB,IAAA;AAAA,IAChB,mBAAA,CAAoB,CAAA;AAAA,KAGvB,eAAA;EAAoB,IAAA;AAAA;AAAA,KACpB,iBAAA;EAAsB,IAAA;AAAA;AAAA,KACtB,gBAAA;EAAqB,IAAA;AAAA;;KAGd,oBAAA,4BAAgD,WAAA,MAC1D,kBAAA,CAAmB,SAAA,EAAW,eAAA,mCAAkD,CAAA,GAAI,KAAA;;KAG1E,sBAAA,4BAAkD,WAAA,MAC5D,kBAAA,CAAmB,SAAA,EAAW,iBAAA,mCAAoD,CAAA,GAAI,KAAA;;KAG5E,qBAAA,4BAAiD,WAAA,MAC3D,kBAAA,CAAmB,SAAA,EAAW,gBAAA,mCAAmD,CAAA,GAAI,KAAA;;;;;;;AAlDvF;KA2DK,WAAA,gDACS,CAAA,IAAK,CAAA,CAAE,CAAA,8CACb,CAAA;;;;;;;;;;;;;KAoBH,mBAAA,4BAA+C,WAAA,MAClD,WAAA,CAAY,oBAAA,CAAqB,SAAA,oEAE7B,WAAA,CAAY,sBAAA,CAAuB,SAAA,sEAEjC,WAAA,CAAY,qBAAA,CAAsB,SAAA,yEAE5B,SAAA;;;;UASG,WAAA;EACf,KAAA,EAAO,YAAA,CAAa,CAAA;EACpB,OAAA,EAAS,cAAA,CAAe,CAAA;EACxB,OAAA,IAAW,OAAA;AAAA;;;;;;;;;UAWI,kBAAA;EA5GwD;EA8GvE,MAAA,GAAS,GAAA;EA9GkF;EAgH3F,YAAA,GAAe,OAAA,CAAQ,CAAA;EAhH8E;EAkHrG,cAAA,GAAiB,OAAA,CAAQ,CAAA;AAAA;AAAA,iBA2DX,iBAAA,kCAAmD,WAAA,GAAA,CACjE,SAAA,EAAW,mBAAA,CAAoB,SAAA,GAC/B,OAAA,GAAU,kBAAA,CACR,oBAAA,CAAqB,SAAA,GACrB,sBAAA,CAAuB,SAAA,GACvB,qBAAA,CAAsB,SAAA,KAEvB,WAAA,CAAY,oBAAA,CAAqB,SAAA,GAAY,sBAAA,CAAuB,SAAA;AAlK9D;;;;;;;;;AAAA,KAgOJ,cAAA,uBAAqC,WAAA,uDAClC,IAAA,WACG,IAAA,YACP,KAAA,qBACkB,IAAA,gDAAoD,OAAA,OAAc,IAAA,EAAM,IAAA;;;;;;;;;;;;;;;;;AAxNjE;;;;;AAGA;;;;;AACE;;;;;AAI/B;;;;;AAJ+B,KA0P1B,iBAAA,+CAAgE,CAAA,yBACzD,GAAA,IAAO,CAAA,aACP,GAAA,GAAM,CAAA;AAAA,KAEb,UAAA,kBAA4B,UAAA,qBAA+B,UAAA,wBAAkC,iBAAA,UAEhG,QAAA,IAEA,iBAAA,YAA6B,UAAA,IAC7B,iBAAA,WAA4B,GAAA;AAAA,iBAEd,cAAA,kBACG,UAAA,GAAa,KAAA,qBACX,UAAA,GAAa,KAAA,uBACX,KAAA,mCACY,QAAA,oDACA,UAAA,6BACvB,eAAA,GAAkB,eAAA,CAAA,CAE5B,QAAA;EACE,SAAA,EAAW,EAAA;EACX,WAAA,EAAa,EAAA;EACb,KAAA,GAAQ,IAAA;IAAQ,KAAA,EAAO,QAAA;IAAU,OAAA,EAAS,UAAA;IAAY,MAAA,EAAQ,GAAA;EAAA,MAAU,CAAA;AAAA,IACtE,cAAA,CAAe,EAAA,EAAI,QAAA,aACrB,cAAA,CAAe,EAAA,EAAI,UAAA;EAErB,SAAA,EAAW,EAAA;EACX,WAAA,EAAa,EAAA;EACb,KAAA,GAAQ,IAAA,EAAM,UAAA,CAAW,QAAA,EAAU,UAAA,EAAY,GAAA,MAAS,CAAA;AAAA"}

package/dist/dev/core/composition/create-composition.js

@@ -0,0 +1,85 @@
+import { signal } from "../signals/primitives.js";
+//#region src/core/composition/create-composition.ts
+/**
+* Create a composition from a set of behaviors.
+*
+* Composition unions the behaviors' declared `stateKeys` / `contextKeys`
+* to know which signals to create. Each signal is seeded from
+* `initialState` / `initialContext` when supplied, defaulting to
+* `undefined`. Behaviors are responsible for writing their own slots
+* once their preconditions are met.
+*
+* Cross-behavior type conflicts (e.g. two behaviors disagreeing on a
+* field's type) surface as a compose-time type error via
+* `ValidateComposition`.
+*
+* @example
+* ```ts
+* const composition = createComposition([resolvePresentation, switchVideoTrack], {
+*   config: { parsePresentation: parseMultivariantPlaylist, initialBandwidth: 2_000_000 },
+*   initialState: { bandwidthState: { fastEstimate: 0, ... } },
+* });
+* ```
+*/
+/**
+* Create a typed signal map for a given set of keys, seeded from an
+* optional partial initial value.
+*
+* Pipeline: `Set` dedupes the iterable (insertion order preserved, so
+* first occurrence wins) → `Object.fromEntries` materializes one
+* `signal()` per unique key, seeded from `initial[key]` or `undefined`.
+*
+* Per-key value types live in TypeScript only — at runtime every signal
+* is `Signal<unknown>`. The boundary cast at the return narrows the wide
+* `Record<PropertyKey, Signal<unknown>>` shape to the caller's expected
+* per-key types from `S`.
+*
+* Used by `createComposition` to derive engine state/context maps from
+* the union of behaviors' declared `stateKeys` / `contextKeys`.
+*
+* @example
+* ```ts
+* interface State { count?: number; label?: string }
+* const state = buildSignalMap<State>(['count', 'label'], { count: 5 });
+* state.count.get(); // 5
+* state.label.get(); // undefined
+* ```
+*/
+function buildSignalMap(keys, initial) {
+	const init = initial;
+	const uniqueKeys = new Set(keys);
+	return Object.fromEntries([...uniqueKeys].map((key) => [key, signal(init[key])]));
+}
+function createComposition(behaviors, options) {
+	const validBehaviors = behaviors;
+	const state = buildSignalMap(validBehaviors.flatMap((b) => b.stateKeys), options?.initialState ?? {});
+	const context = buildSignalMap(validBehaviors.flatMap((b) => b.contextKeys), options?.initialContext ?? {});
+	const deps = {
+		state,
+		context,
+		config: options?.config ?? {}
+	};
+	const cleanups = validBehaviors.map((behavior) => behavior.setup(deps));
+	return {
+		state,
+		context,
+		async destroy() {
+			const results = [];
+			for (const cleanup of cleanups) {
+				if (cleanup == null) continue;
+				if (typeof cleanup === "function") results.push(cleanup());
+				else if ("destroy" in cleanup) results.push(cleanup.destroy());
+			}
+			await Promise.all(results);
+			for (const sig of Object.values(state)) sig.set(void 0);
+			for (const sig of Object.values(context)) sig.set(void 0);
+		}
+	};
+}
+function defineBehavior(behavior) {
+	return behavior;
+}
+//#endregion
+export { createComposition, defineBehavior };
+
+//# sourceMappingURL=create-composition.js.map