@pibbl/core 0.0.1 → 0.0.3-alpha.109.1

package/README.md

@@ -1,6 +1,6 @@
 # @pibbl/core
 
-> **ALPHA — NOT FOR PRODUCTION USE.** Pibbl 0.0.1 is experimental. APIs may change or be removed without notice. Use it only for evaluation and experimentation.
+> **ALPHA — NOT FOR PRODUCTION USE.** Pibbl 0.0.2 is experimental. APIs may change or be removed without notice. Use it only for evaluation and experimentation.
 
 The ESM Canvas 2D component runtime for Pibbl, with an automatic JSX runtime and
 an equivalent `createElement` API. It has no React dependency. Drawing stays on

package/THIRD_PARTY_NOTICES.txt

@@ -203,3 +203,84 @@ License: Apache-2.0
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
+
+
+Recording/GIF WASM dependency: gif-0.14.1
+Source: https://github.com/image-rs/image-gif
+License: MIT
+
+The MIT License (MIT)
+
+Copyright (c) 2015 nwin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+Recording/GIF WASM dependency: color_quant-1.1.0
+Source: https://github.com/image-rs/color_quant
+License: MIT
+
+The MIT License (MIT)
+
+Copyright (c) 2016 PistonDevelopers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+Recording/GIF WASM dependency: weezl-0.1.12
+Source: https://github.com/image-rs/weezl
+License: MIT
+
+The MIT License (MIT)
+
+Copyright (c) HeroicKatora 2020
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/features/machines/animation.d.ts

@@ -0,0 +1,64 @@
+import type { PibblAnimationProgram, PibblPlaybackOptions } from '../../lib/animation/types.js';
+import type { MachineTask, MachineTaskContext, MachineEvent } from './types.js';
+/**
+ * Playback options owned by a machine animation task.
+ *
+ * Lifecycle callbacks are deliberately omitted: task completion and failure
+ * become the invocation's `onDone` and `onError` transitions instead.
+ *
+ * @see {@link playAnimation}
+ */
+export interface MachineAnimationOptions {
+    /**
+     * Selects the existing writer-conflict policy for this state-owned playback.
+     * Defaults to the animation runtime's explicit-error policy.
+     */
+    readonly conflict?: PibblPlaybackOptions['conflict'];
+    /** Optional label included in animation scheduler diagnostics. */
+    readonly debugName?: string;
+}
+/**
+ * Builds the animation program for one state entry.
+ *
+ * The callback runs once when the invocation starts. It receives the entry's
+ * immutable context and event, the machine input, the cancellation signal, and
+ * `send` for application-defined machine events.
+ *
+ * @typeParam Context - Context captured when this state entry began.
+ * @typeParam Event - Event type accepted by the owning machine.
+ * @typeParam Input - Input captured by the owning machine actor.
+ * @param context - Immutable state-entry values used to create this program.
+ * @returns The program that the machine invocation owns until it finishes or is cancelled.
+ * @see {@link MachineTaskContext}
+ */
+export type MachineAnimationProgramFactory<Context, Event extends MachineEvent, Input> = (context: MachineTaskContext<Context, Event, Input>) => PibblAnimationProgram;
+/**
+ * Adapts a Pibbl animation program into state-owned cancelable machine work.
+ *
+ * A finite program resolves the state invocation after the animation scheduler
+ * delivers its `finish` event, allowing the invocation's `onDone` transition to
+ * run. Repeating programs remain active until their state exits or the actor
+ * stops. Cancellation disposes only this adapter's playback and never sends a
+ * completion or error transition.
+ *
+ * @typeParam Context - Context captured when this state entry began.
+ * @typeParam Event - Event type accepted by the owning machine.
+ * @typeParam Input - Input captured by the owning machine actor.
+ * @param program - Factory that creates the program for this state entry.
+ * @param options - Playback conflict policy and diagnostic label.
+ * @returns A task suitable for a state's `invoke.task` field.
+ *
+ * @example
+ * ```ts
+ * running: {
+ *   invoke: {
+ *     task: playAnimation(({ input }) =>
+ *       repeat(drive(input.frame, input.animations.run), { iterations: Infinity }),
+ *     ),
+ *   },
+ * }
+ * ```
+ *
+ * @see {@link MachineAnimationOptions}
+ */
+export declare function playAnimation<Context, Event extends MachineEvent, Input>(program: MachineAnimationProgramFactory<Context, Event, Input>, options?: MachineAnimationOptions): MachineTask<Context, Event, Input, void>;

package/dist/features/machines/animation.js

@@ -0,0 +1,55 @@
+import {
+  createAnimationPlaybackController
+} from "../../lib/animation/playback.js";
+function playAnimation(program, options = {}) {
+  return (taskContext) => {
+    if (taskContext.signal.aborted) return;
+    const animation = program(taskContext);
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let controller;
+      controller = createAnimationPlaybackController(animation, {
+        conflict: options.conflict,
+        debugName: options.debugName,
+        onEvent(event) {
+          if (event.type !== "finish" || settled) return;
+          settled = true;
+          detachAbort();
+          controller.dispose();
+          resolve();
+        },
+        onError(error) {
+          if (settled) return;
+          settled = true;
+          detachAbort();
+          controller.dispose();
+          reject(error);
+        }
+      });
+      const abort = () => {
+        if (settled) return;
+        settled = true;
+        detachAbort();
+        controller.dispose();
+      };
+      const detachAbort = () => {
+        taskContext.signal.removeEventListener("abort", abort);
+      };
+      taskContext.signal.addEventListener("abort", abort, { once: true });
+      if (taskContext.signal.aborted) {
+        abort();
+        return;
+      }
+      try {
+        controller.handle.play();
+      } catch (error) {
+        abort();
+        reject(error);
+      }
+    });
+  };
+}
+export {
+  playAnimation
+};
+//# sourceMappingURL=animation.js.map

package/dist/features/machines/animation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/features/machines/animation.ts"],
+  "sourcesContent": ["import {\n  createAnimationPlaybackController,\n  type AnimationPlaybackController,\n} from '../../lib/animation/playback.js';\nimport type {\n  PibblAnimationProgram,\n  PibblPlaybackOptions,\n} from '../../lib/animation/types.js';\nimport type {\n  MachineTask,\n  MachineTaskContext,\n  MachineEvent,\n} from './types.js';\n\n/**\n * Playback options owned by a machine animation task.\n *\n * Lifecycle callbacks are deliberately omitted: task completion and failure\n * become the invocation's `onDone` and `onError` transitions instead.\n *\n * @see {@link playAnimation}\n */\nexport interface MachineAnimationOptions {\n  /**\n   * Selects the existing writer-conflict policy for this state-owned playback.\n   * Defaults to the animation runtime's explicit-error policy.\n   */\n  readonly conflict?: PibblPlaybackOptions['conflict'];\n  /** Optional label included in animation scheduler diagnostics. */\n  readonly debugName?: string;\n}\n\n/**\n * Builds the animation program for one state entry.\n *\n * The callback runs once when the invocation starts. It receives the entry's\n * immutable context and event, the machine input, the cancellation signal, and\n * `send` for application-defined machine events.\n *\n * @typeParam Context - Context captured when this state entry began.\n * @typeParam Event - Event type accepted by the owning machine.\n * @typeParam Input - Input captured by the owning machine actor.\n * @param context - Immutable state-entry values used to create this program.\n * @returns The program that the machine invocation owns until it finishes or is cancelled.\n * @see {@link MachineTaskContext}\n */\nexport type MachineAnimationProgramFactory<Context, Event extends MachineEvent, Input> = (\n  context: MachineTaskContext<Context, Event, Input>,\n) => PibblAnimationProgram;\n\n/**\n * Adapts a Pibbl animation program into state-owned cancelable machine work.\n *\n * A finite program resolves the state invocation after the animation scheduler\n * delivers its `finish` event, allowing the invocation's `onDone` transition to\n * run. Repeating programs remain active until their state exits or the actor\n * stops. Cancellation disposes only this adapter's playback and never sends a\n * completion or error transition.\n *\n * @typeParam Context - Context captured when this state entry began.\n * @typeParam Event - Event type accepted by the owning machine.\n * @typeParam Input - Input captured by the owning machine actor.\n * @param program - Factory that creates the program for this state entry.\n * @param options - Playback conflict policy and diagnostic label.\n * @returns A task suitable for a state's `invoke.task` field.\n *\n * @example\n * ```ts\n * running: {\n *   invoke: {\n *     task: playAnimation(({ input }) =>\n *       repeat(drive(input.frame, input.animations.run), { iterations: Infinity }),\n *     ),\n *   },\n * }\n * ```\n *\n * @see {@link MachineAnimationOptions}\n */\nexport function playAnimation<Context, Event extends MachineEvent, Input>(\n  program: MachineAnimationProgramFactory<Context, Event, Input>,\n  options: MachineAnimationOptions = {},\n): MachineTask<Context, Event, Input, void> {\n  return taskContext => {\n    if (taskContext.signal.aborted) return;\n\n    const animation = program(taskContext);\n    return new Promise<void>((resolve, reject) => {\n      let settled = false;\n      let controller!: AnimationPlaybackController;\n      controller = createAnimationPlaybackController(animation, {\n        conflict: options.conflict,\n        debugName: options.debugName,\n        onEvent(event): void {\n          if (event.type !== 'finish' || settled) return;\n          settled = true;\n          detachAbort();\n          controller.dispose();\n          resolve();\n        },\n        onError(error): void {\n          if (settled) return;\n          settled = true;\n          detachAbort();\n          controller.dispose();\n          reject(error);\n        },\n      });\n\n      const abort = (): void => {\n        if (settled) return;\n        settled = true;\n        detachAbort();\n        controller.dispose();\n      };\n      const detachAbort = (): void => {\n        taskContext.signal.removeEventListener('abort', abort);\n      };\n\n      taskContext.signal.addEventListener('abort', abort, { once: true });\n      if (taskContext.signal.aborted) {\n        abort();\n        return;\n      }\n      try {\n        controller.handle.play();\n      } catch (error) {\n        abort();\n        reject(error);\n      }\n    });\n  };\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,OAEK;AA4EA,SAAS,cACd,SACA,UAAmC,CAAC,GACM;AAC1C,SAAO,iBAAe;AACpB,QAAI,YAAY,OAAO,QAAS;AAEhC,UAAM,YAAY,QAAQ,WAAW;AACrC,WAAO,IAAI,QAAc,CAAC,SAAS,WAAW;AAC5C,UAAI,UAAU;AACd,UAAI;AACJ,mBAAa,kCAAkC,WAAW;AAAA,QACxD,UAAU,QAAQ;AAAA,QAClB,WAAW,QAAQ;AAAA,QACnB,QAAQ,OAAa;AACnB,cAAI,MAAM,SAAS,YAAY,QAAS;AACxC,oBAAU;AACV,sBAAY;AACZ,qBAAW,QAAQ;AACnB,kBAAQ;AAAA,QACV;AAAA,QACA,QAAQ,OAAa;AACnB,cAAI,QAAS;AACb,oBAAU;AACV,sBAAY;AACZ,qBAAW,QAAQ;AACnB,iBAAO,KAAK;AAAA,QACd;AAAA,MACF,CAAC;AAED,YAAM,QAAQ,MAAY;AACxB,YAAI,QAAS;AACb,kBAAU;AACV,oBAAY;AACZ,mBAAW,QAAQ;AAAA,MACrB;AACA,YAAM,cAAc,MAAY;AAC9B,oBAAY,OAAO,oBAAoB,SAAS,KAAK;AAAA,MACvD;AAEA,kBAAY,OAAO,iBAAiB,SAAS,OAAO,EAAE,MAAM,KAAK,CAAC;AAClE,UAAI,YAAY,OAAO,SAAS;AAC9B,cAAM;AACN;AAAA,MACF;AACA,UAAI;AACF,mBAAW,OAAO,KAAK;AAAA,MACzB,SAAS,OAAO;AACd,cAAM;AACN,eAAO,KAAK;AAAA,MACd;AAAA,IACF,CAAC;AAAA,EACH;AACF;",
+  "names": []
+}

package/dist/features/machines/animation.mjs

@@ -0,0 +1 @@
+export * from './animation.js';

package/dist/features/machines/assign.d.ts

@@ -0,0 +1,16 @@
+import type { MachineAction, MachineActionContext, MachineEvent } from './types.js';
+/** @internal Returns the context patch represented by an assign action. */
+export declare function assignmentOf(action: Function): ((context: MachineActionContext<object, MachineEvent, unknown>) => object) | undefined;
+/**
+ * Creates an action that shallowly merges a context patch. Earlier assignments in the same
+ * transition are visible to later actions. Context itself remains application-owned data.
+ *
+ * @example
+ * ```ts
+ * const collect = assign(({ context }) => ({ coins: context.coins + 1 }));
+ * ```
+ * @param update - Produces the shallow context patch for this transition.
+ * @returns An action accepted by state entry, exit, and transition action lists.
+ * @see {@link MachineAction}
+ */
+export declare function assign<Context extends object, Event extends MachineEvent, Input>(update: (context: MachineActionContext<Context, Event, Input>) => Partial<Context>): MachineAction<Context, Event, Input>;

package/dist/features/machines/assign.js

@@ -0,0 +1,15 @@
+const assignments = /* @__PURE__ */ new WeakMap();
+function assignmentOf(action) {
+  return assignments.get(action);
+}
+function assign(update) {
+  const action = () => {
+  };
+  assignments.set(action, update);
+  return action;
+}
+export {
+  assign,
+  assignmentOf
+};
+//# sourceMappingURL=assign.js.map

package/dist/features/machines/assign.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/features/machines/assign.ts"],
+  "sourcesContent": ["import type { MachineAction, MachineActionContext, MachineEvent } from './types.js';\n\nconst assignments = new WeakMap<Function, (context: MachineActionContext<object, MachineEvent, unknown>) => object>();\n\n/** @internal Returns the context patch represented by an assign action. */\nexport function assignmentOf(action: Function): ((context: MachineActionContext<object, MachineEvent, unknown>) => object) | undefined {\n  return assignments.get(action);\n}\n\n/**\n * Creates an action that shallowly merges a context patch. Earlier assignments in the same\n * transition are visible to later actions. Context itself remains application-owned data.\n *\n * @example\n * ```ts\n * const collect = assign(({ context }) => ({ coins: context.coins + 1 }));\n * ```\n * @param update - Produces the shallow context patch for this transition.\n * @returns An action accepted by state entry, exit, and transition action lists.\n * @see {@link MachineAction}\n */\nexport function assign<Context extends object, Event extends MachineEvent, Input>(\n  update: (context: MachineActionContext<Context, Event, Input>) => Partial<Context>,\n): MachineAction<Context, Event, Input> {\n  const action: MachineAction<Context, Event, Input> = () => {};\n  assignments.set(action, update as unknown as (context: MachineActionContext<object, MachineEvent, unknown>) => object);\n  return action;\n}\n"],
+  "mappings": "AAEA,MAAM,cAAc,oBAAI,QAA4F;AAG7G,SAAS,aAAa,QAA0G;AACrI,SAAO,YAAY,IAAI,MAAM;AAC/B;AAcO,SAAS,OACd,QACsC;AACtC,QAAM,SAA+C,MAAM;AAAA,EAAC;AAC5D,cAAY,IAAI,QAAQ,MAA6F;AACrH,SAAO;AACT;",
+  "names": []
+}

package/dist/features/machines/callback.d.ts

@@ -0,0 +1,9 @@
+import type { MachineEvent, MachineTask } from './types.js';
+/**
+ * Marks callback-style cancelable work as a machine task. The callback may return a cleanup;
+ * its cleanup runs exactly once when the owning state exits or the actor stops.
+ * @param callback - Callback task to retain as state-owned work.
+ * @returns The same callback, typed for an invocation's `task` field.
+ * @see {@link MachineTask}
+ */
+export declare function fromCallback<Context, Event extends MachineEvent, Input>(callback: MachineTask<Context, Event, Input>): MachineTask<Context, Event, Input>;

package/dist/features/machines/callback.js

@@ -0,0 +1,7 @@
+function fromCallback(callback) {
+  return callback;
+}
+export {
+  fromCallback
+};
+//# sourceMappingURL=callback.js.map

package/dist/features/machines/callback.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/features/machines/callback.ts"],
+  "sourcesContent": ["import type { MachineEvent, MachineTask } from './types.js';\n\n/**\n * Marks callback-style cancelable work as a machine task. The callback may return a cleanup;\n * its cleanup runs exactly once when the owning state exits or the actor stops.\n * @param callback - Callback task to retain as state-owned work.\n * @returns The same callback, typed for an invocation's `task` field.\n * @see {@link MachineTask}\n */\nexport function fromCallback<Context, Event extends MachineEvent, Input>(\n  callback: MachineTask<Context, Event, Input>,\n): MachineTask<Context, Event, Input> {\n  return callback;\n}\n"],
+  "mappings": "AASO,SAAS,aACd,UACoC;AACpC,SAAO;AACT;",
+  "names": []
+}

package/dist/features/machines/hook.d.ts

@@ -0,0 +1,30 @@
+import type { createMachine } from "./runtime.js";
+import type { MachineActor, MachineDefinition, MachineEvent } from './types.js';
+/**
+ * Creates one component-owned state-machine actor for a hook slot.
+ *
+ * The actor starts only after its mounting render commits successfully and stops
+ * when the component unmounts. Its input is captured on the initial mount;
+ * changing an input object on a later render does not recreate or restart the
+ * actor. Use machine events for application state changes.
+ *
+ * @typeParam Context - Immutable machine context carried by each snapshot.
+ * @typeParam Event - Events accepted by the machine actor.
+ * @typeParam Input - Immutable input captured when this hook slot mounts.
+ * @param definition - Immutable machine behavior shared by all actor instances.
+ * @param options - Input used to initialize this mounted actor.
+ * @returns A stable actor with a readonly reactive snapshot.
+ *
+ * @example
+ * ```tsx
+ * const actor = useMachine(menuMachine, { input: { initialOpen: false } });
+ * const open = () => actor.send({ type: 'OPEN' });
+ * return <Text>{actor.snapshot.get().value}</Text>;
+ * ```
+ *
+ * @see {@link createMachine}
+ * @see {@link MachineActor}
+ */
+export declare function useMachine<Context, Event extends MachineEvent, Input, State extends string>(definition: MachineDefinition<Context, Event, Input, State>, options: {
+    readonly input: Input;
+}): MachineActor<Context, Event, Input, State>;

package/dist/features/machines/hook.js

@@ -0,0 +1,37 @@
+import { GLOBAL_STATE } from "../../lib/global-state.js";
+import { requireHookContext, useHookSlot } from "../../lib/hooks/hook-slot.js";
+import { createMachine } from "./runtime.js";
+function isCurrentSlot(slot) {
+  return !slot.componentRefs.teardowns.closed && !slot.pibblInstance.mainTeardowns.closed && GLOBAL_STATE.pibblInstances.get(slot.pibblInstance.canvas) === slot.pibblInstance && slot.pibblInstance.refs.get(slot.componentRefs.id) === slot.componentRefs;
+}
+function useMachine(definition, options) {
+  const { componentRefs, pibblInstance } = requireHookContext();
+  const slot = useHookSlot(
+    "machine",
+    (teardowns) => {
+      const actor = createMachine(definition, options);
+      const value = {
+        actor,
+        componentRefs,
+        pibblInstance,
+        started: false
+      };
+      teardowns.add(() => actor.stop());
+      return value;
+    }
+  ).value;
+  const transaction = GLOBAL_STATE.renderTransaction;
+  if (!transaction) {
+    throw new Error("useMachine requires an active Pibbl render transaction.");
+  }
+  transaction.onFinish((success) => {
+    if (!success || slot.started || !isCurrentSlot(slot)) return;
+    slot.started = true;
+    slot.actor.start();
+  });
+  return slot.actor;
+}
+export {
+  useMachine
+};
+//# sourceMappingURL=hook.js.map

package/dist/features/machines/hook.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/features/machines/hook.ts"],
+  "sourcesContent": ["import { GLOBAL_STATE } from '../../lib/global-state.js';\nimport type { PibblComponentRefs, PibblInstance } from '../../lib/types.js';\nimport { requireHookContext, useHookSlot } from '../../lib/hooks/hook-slot.js';\nimport { createMachine } from './runtime.js';\nimport type {\n  MachineActor,\n  MachineDefinition,\n  MachineEvent,\n} from './types.js';\n\ninterface MachineHookSlot<Context, Event extends MachineEvent, Input, State extends string> {\n  readonly actor: MachineActor<Context, Event, Input, State>;\n  readonly componentRefs: PibblComponentRefs<unknown>;\n  readonly pibblInstance: PibblInstance;\n  started: boolean;\n}\n\nfunction isCurrentSlot<Context, Event extends MachineEvent, Input, State extends string>(\n  slot: MachineHookSlot<Context, Event, Input, State>,\n): boolean {\n  return !slot.componentRefs.teardowns.closed &&\n    !slot.pibblInstance.mainTeardowns.closed &&\n    GLOBAL_STATE.pibblInstances.get(slot.pibblInstance.canvas) === slot.pibblInstance &&\n    slot.pibblInstance.refs.get(slot.componentRefs.id) === slot.componentRefs;\n}\n\n/**\n * Creates one component-owned state-machine actor for a hook slot.\n *\n * The actor starts only after its mounting render commits successfully and stops\n * when the component unmounts. Its input is captured on the initial mount;\n * changing an input object on a later render does not recreate or restart the\n * actor. Use machine events for application state changes.\n *\n * @typeParam Context - Immutable machine context carried by each snapshot.\n * @typeParam Event - Events accepted by the machine actor.\n * @typeParam Input - Immutable input captured when this hook slot mounts.\n * @param definition - Immutable machine behavior shared by all actor instances.\n * @param options - Input used to initialize this mounted actor.\n * @returns A stable actor with a readonly reactive snapshot.\n *\n * @example\n * ```tsx\n * const actor = useMachine(menuMachine, { input: { initialOpen: false } });\n * const open = () => actor.send({ type: 'OPEN' });\n * return <Text>{actor.snapshot.get().value}</Text>;\n * ```\n *\n * @see {@link createMachine}\n * @see {@link MachineActor}\n */\nexport function useMachine<Context, Event extends MachineEvent, Input, State extends string>(\n  definition: MachineDefinition<Context, Event, Input, State>,\n  options: { readonly input: Input },\n): MachineActor<Context, Event, Input, State> {\n  const { componentRefs, pibblInstance } = requireHookContext();\n\n  const slot = useHookSlot<MachineHookSlot<Context, Event, Input, State>>(\n    'machine',\n    teardowns => {\n      const actor = createMachine(definition, options);\n      const value: MachineHookSlot<Context, Event, Input, State> = {\n        actor,\n        componentRefs,\n        pibblInstance,\n        started: false,\n      };\n      teardowns.add(() => actor.stop());\n      return value;\n    },\n  ).value;\n\n  const transaction = GLOBAL_STATE.renderTransaction;\n  if (!transaction) {\n    throw new Error('useMachine requires an active Pibbl render transaction.');\n  }\n  transaction.onFinish(success => {\n    if (!success || slot.started || !isCurrentSlot(slot)) return;\n    slot.started = true;\n    slot.actor.start();\n  });\n  return slot.actor;\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAE7B,SAAS,oBAAoB,mBAAmB;AAChD,SAAS,qBAAqB;AAc9B,SAAS,cACP,MACS;AACT,SAAO,CAAC,KAAK,cAAc,UAAU,UACnC,CAAC,KAAK,cAAc,cAAc,UAClC,aAAa,eAAe,IAAI,KAAK,cAAc,MAAM,MAAM,KAAK,iBACpE,KAAK,cAAc,KAAK,IAAI,KAAK,cAAc,EAAE,MAAM,KAAK;AAChE;AA2BO,SAAS,WACd,YACA,SAC4C;AAC5C,QAAM,EAAE,eAAe,cAAc,IAAI,mBAAmB;AAE5D,QAAM,OAAO;AAAA,IACX;AAAA,IACA,eAAa;AACX,YAAM,QAAQ,cAAc,YAAY,OAAO;AAC/C,YAAM,QAAuD;AAAA,QAC3D;AAAA,QACA;AAAA,QACA;AAAA,QACA,SAAS;AAAA,MACX;AACA,gBAAU,IAAI,MAAM,MAAM,KAAK,CAAC;AAChC,aAAO;AAAA,IACT;AAAA,EACF,EAAE;AAEF,QAAM,cAAc,aAAa;AACjC,MAAI,CAAC,aAAa;AAChB,UAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AACA,cAAY,SAAS,aAAW;AAC9B,QAAI,CAAC,WAAW,KAAK,WAAW,CAAC,cAAc,IAAI,EAAG;AACtD,SAAK,UAAU;AACf,SAAK,MAAM,MAAM;AAAA,EACnB,CAAC;AACD,SAAO,KAAK;AACd;",
+  "names": []
+}

package/dist/features/machines/index.d.ts

@@ -0,0 +1,6 @@
+/** General-purpose, signal-backed flat state machines. */
+export { assign } from './assign.js';
+export { fromCallback } from './callback.js';
+export { createMachine, defineMachine } from './runtime.js';
+export { useMachine } from './hook.js';
+export type { CreateMachineOptions, MachineAction, MachineActionContext, MachineActions, MachineActor, MachineDefinition, MachineEvent, MachineEventRoutes, MachineInvocation, MachineSnapshot, MachineState, MachineStatus, MachineTask, MachineTaskCleanup, MachineTaskContext, MachineTaskDoneEvent, MachineTaskErrorEvent, MachineTransition, MachineTransitionConfig, } from './types.js';

package/dist/features/machines/index.js

@@ -0,0 +1,12 @@
+import { assign } from "./assign.js";
+import { fromCallback } from "./callback.js";
+import { createMachine, defineMachine } from "./runtime.js";
+import { useMachine } from "./hook.js";
+export {
+  assign,
+  createMachine,
+  defineMachine,
+  fromCallback,
+  useMachine
+};
+//# sourceMappingURL=index.js.map

package/dist/features/machines/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/features/machines/index.ts"],
+  "sourcesContent": ["/** General-purpose, signal-backed flat state machines. */\nexport { assign } from './assign.js';\nexport { fromCallback } from './callback.js';\nexport { createMachine, defineMachine } from './runtime.js';\nexport { useMachine } from './hook.js';\nexport type {\n  CreateMachineOptions,\n  MachineAction,\n  MachineActionContext,\n  MachineActions,\n  MachineActor,\n  MachineDefinition,\n  MachineEvent,\n  MachineEventRoutes,\n  MachineInvocation,\n  MachineSnapshot,\n  MachineState,\n  MachineStatus,\n  MachineTask,\n  MachineTaskCleanup,\n  MachineTaskContext,\n  MachineTaskDoneEvent,\n  MachineTaskErrorEvent,\n  MachineTransition,\n  MachineTransitionConfig,\n} from './types.js';\n"],
+  "mappings": "AACA,SAAS,cAAc;AACvB,SAAS,oBAAoB;AAC7B,SAAS,eAAe,qBAAqB;AAC7C,SAAS,kBAAkB;",
+  "names": []
+}

package/dist/features/machines/index.mjs

@@ -0,0 +1 @@
+export * from './index.js';

package/dist/features/machines/runtime.d.ts

@@ -0,0 +1,18 @@
+import type { CreateMachineOptions, MachineActor, MachineDefinition, MachineEvent } from './types.js';
+/**
+ * Validates and records a reusable flat machine definition. Calling this function performs no
+ * work and creates no actor; use {@link createMachine} or `useMachine` to execute it.
+ * @param definition - Reusable machine behavior to validate and normalize.
+ * @returns The supplied definition, suitable for actor creation.
+ * @see {@link MachineDefinition}
+ */
+export declare function defineMachine<Context, Event extends MachineEvent, Input = undefined, State extends string = string>(definition: MachineDefinition<Context, Event, Input, State>): MachineDefinition<Context, Event, Input, State>;
+/**
+ * Creates an explicitly owned, initially idle machine actor. Call `start()` when ownership begins
+ * and `stop()` when it ends. The actor has no renderer, scheduler, or animation dependency.
+ * @param definition - Reusable behavior previously authored with {@link defineMachine}.
+ * @param options - Immutable input supplied to this actor.
+ * @returns An idle actor that owns no task until it starts.
+ * @see {@link MachineActor}
+ */
+export declare function createMachine<Context, Event extends MachineEvent, Input, State extends string = string>(definition: MachineDefinition<Context, Event, Input, State>, options: CreateMachineOptions<Input>): MachineActor<Context, Event, Input, State>;