@pibbl/core 0.0.1

package/dist/lib/manipulation/types.d.ts

@@ -0,0 +1,178 @@
+import type { PibblManipulationActive, PibblManipulationFrameProps, PibblManipulationGeometry, PibblManipulationOptions, PibblManipulationSnapshot } from "./controller-types.js";
+import type { PibblDragHandleProps } from "./handles.js";
+/**
+ * Position and dimensions of a manipulation target in logical coordinates.
+ *
+ * @see {@link PibblManipulationOptions}
+ * @see {@link PibblManipulationGeometry}
+ * @see {@link PibblManipulationFrameProps}
+ */
+export interface PibblManipulationBox {
+    /** Left edge coordinate or inset. See {@link PibblManipulationBox}. */
+    readonly left: number;
+    /** Top edge value or top envelope guide. See {@link PibblManipulationBox}. */
+    readonly top: number;
+    /**
+     * Horizontal extent in the units of the containing geometry or surface. See
+     * {@link PibblManipulationBox}.
+     */
+    readonly width: number;
+    /**
+     * Vertical extent in the units of the containing geometry or surface. See
+     * {@link PibblManipulationBox}.
+     */
+    readonly height: number;
+}
+/**
+ * A manipulation input point in logical coordinates.
+ *
+ * @see {@link PibblManipulationGeometry}
+ */
+export interface PibblManipulationPoint {
+    /**
+     * Horizontal coordinate or displacement in the containing coordinate system. See
+     * {@link PibblManipulationPoint}.
+     */
+    readonly x: number;
+    /**
+     * Vertical coordinate or displacement in the containing coordinate system. See
+     * {@link PibblManipulationPoint}.
+     */
+    readonly y: number;
+}
+export interface PibblManipulationModifiers {
+    readonly shift?: boolean;
+    readonly alt?: boolean;
+    readonly ctrl?: boolean;
+    readonly meta?: boolean;
+}
+/**
+ * Modifier-key condition used to activate manipulation snapping or affordances.
+ *
+ * @see {@link PibblDragHandleProps}
+ */
+export type PibblManipulationWhen = 'always' | 'shift' | 'alt' | 'ctrl' | 'meta';
+/**
+ * An edge or corner at which a resize handle is placed.
+ *
+ * @see {@link PibblManipulationSnapshot}
+ * @see {@link PibblManipulationActive}
+ */
+export type PibblResizePosition = 'top-left' | 'top' | 'top-right' | 'right' | 'bottom-right' | 'bottom' | 'bottom-left' | 'left';
+export interface PibblManipulationMoveSnap {
+    readonly enabled?: boolean;
+    readonly when?: PibblManipulationWhen;
+    readonly step: number | Readonly<{
+        x: number;
+        y: number;
+    }>;
+    readonly origin?: Readonly<{
+        x?: number;
+        y?: number;
+    }>;
+}
+/**
+ * Axis, bounding box, and snapping constraints for translation.
+ *
+ * @see {@link PibblManipulationBox}
+ * @see {@link PibblManipulationMoveSnap}
+ */
+export interface PibblManipulationMoveOptions {
+    /** Selects `"both"`, `"x"`, `"y"` for axis. See {@link PibblManipulationMoveOptions}. */
+    readonly axis?: 'both' | 'x' | 'y';
+    /** Logical region constraining the content or query. See {@link PibblManipulationBox}. */
+    readonly bounds?: PibblManipulationBox;
+    /** Snapping configuration for the manipulation operation. See {@link PibblManipulationMoveSnap}. */
+    readonly snap?: PibblManipulationMoveSnap;
+}
+export interface PibblManipulationResizeSizeSnap {
+    readonly target?: 'size';
+    readonly enabled?: boolean;
+    readonly when?: PibblManipulationWhen;
+    readonly step: number | Readonly<{
+        width: number;
+        height: number;
+    }>;
+}
+export interface PibblManipulationResizeGridSnap {
+    readonly target: 'grid';
+    readonly enabled?: boolean;
+    readonly when?: PibblManipulationWhen;
+    readonly step: number | Readonly<{
+        x: number;
+        y: number;
+    }>;
+    readonly origin?: Readonly<{
+        x?: number;
+        y?: number;
+    }>;
+}
+export interface PibblManipulationAspectRatio {
+    readonly value: 'initial' | number;
+    readonly when?: PibblManipulationWhen;
+}
+/**
+ * Size limits, bounds, aspect ratio, and snapping constraints for resizing.
+ *
+ * @see {@link PibblManipulationBox}
+ * @see {@link PibblManipulationResizeSizeSnap}
+ */
+export interface PibblManipulationResizeOptions {
+    /** Minimum permitted width. See {@link PibblManipulationResizeOptions}. */
+    readonly minWidth?: number;
+    /** Minimum permitted height. See {@link PibblManipulationResizeOptions}. */
+    readonly minHeight?: number;
+    /** Maximum permitted width. See {@link PibblManipulationResizeOptions}. */
+    readonly maxWidth?: number;
+    /** Maximum permitted height. See {@link PibblManipulationResizeOptions}. */
+    readonly maxHeight?: number;
+    /** Logical region constraining the content or query. See {@link PibblManipulationBox}. */
+    readonly bounds?: PibblManipulationBox;
+    /**
+     * Constraint on the manipulated width-to-height ratio. See {@link PibblManipulationAspectRatio}.
+     */
+    readonly aspectRatio?: PibblManipulationAspectRatio;
+    /**
+     * Snapping configuration for the manipulation operation. See
+     * {@link PibblManipulationResizeSizeSnap}, {@link PibblManipulationResizeGridSnap}.
+     */
+    readonly snap?: PibblManipulationResizeSizeSnap | PibblManipulationResizeGridSnap;
+}
+export interface PibblManipulationRotateSnap {
+    readonly enabled?: boolean;
+    readonly when?: PibblManipulationWhen;
+    readonly step: number;
+    readonly origin?: number;
+}
+/**
+ * Angular snapping configuration for rotation.
+ *
+ * @see {@link PibblManipulationRotateSnap}
+ */
+export interface PibblManipulationRotateOptions {
+    /**
+     * Snapping configuration for the manipulation operation. See {@link PibblManipulationRotateSnap}.
+     */
+    readonly snap?: PibblManipulationRotateSnap;
+}
+export interface ManipulationSolveInput {
+    readonly operation: 'move' | 'resize' | 'rotate';
+    readonly handle?: PibblResizePosition;
+    readonly initial: PibblManipulationBox;
+    readonly initialRotation?: number;
+    readonly rotationDelta?: number;
+    readonly initialPoint: PibblManipulationPoint;
+    readonly currentPoint: PibblManipulationPoint;
+    readonly modifiers: PibblManipulationModifiers;
+    readonly move?: PibblManipulationMoveOptions;
+    readonly resize?: PibblManipulationResizeOptions;
+    readonly rotate?: PibblManipulationRotateOptions;
+}
+export interface ManipulationSolveResult {
+    readonly proposed: PibblManipulationBox;
+    readonly applied: PibblManipulationBox;
+    readonly snapActive: boolean;
+    readonly snapSatisfied: boolean;
+    readonly proposedRotation: number;
+    readonly appliedRotation: number;
+}

package/dist/lib/mount-pibbl.d.ts

@@ -0,0 +1,25 @@
+import { Canvas, PibblController, type PibblNode } from './types.js';
+import type { PibblConfig, PibblSurfaceSnapshot } from './surface/types.js';
+import type { PibblBackendDriver, PibblBackendMount, PibblBackendMountOptions } from './backend/types.js';
+type MountPibblConfig = PibblConfig & {
+    parent?: Canvas;
+    surface?: PibblSurfaceSnapshot;
+    driver?: PibblBackendDriver<unknown>;
+};
+export declare function mountPibbl(canvas: Canvas, element: PibblNode, config?: MountPibblConfig): PibblController;
+/**
+ * Mounts a private official-backend Pibbl child under an existing Pibbl root.
+ *
+ * @param canvas - Host canvas for this backend mount. See {@link Canvas}.
+ * @param root - Initial Pibbl node tree. See {@link PibblNode}.
+ * @param options - Backend driver and mount configuration. See {@link PibblBackendMountOptions}.
+ * @returns Mount controls for rendering, resizing, scheduling, and disposal. See
+ * {@link PibblBackendMount} .
+ *
+ * @see {@link Canvas}
+ * @see {@link PibblNode}
+ * @see {@link PibblBackendMountOptions}
+ * @see {@link PibblBackendMount}
+ */
+export declare function mountBackendPibbl<E>(canvas: Canvas, root: PibblNode, options: PibblBackendMountOptions<E>): PibblBackendMount;
+export {};

package/dist/lib/mount-pibbl.js

@@ -0,0 +1,278 @@
+import { reserveHtmlOverlay } from "./html/overlay-config.js";
+import {
+  cleanupPibblInstance,
+  GLOBAL_STATE,
+  NO_PENDING_ROOT
+} from "./global-state.js";
+import { PIBBL_EVENT_TYPES } from "./events/event-definitions.js";
+import {
+  dispatchNativeEvent,
+  refreshInteractionCursor,
+  releaseEventNodeState
+} from "./events/dispatch.js";
+import { createNativeListenerHub } from "./events/native-listener-hub.js";
+import { Teardowns } from "./teardowns.js";
+import {
+  createLegacyLayerSurfaceState,
+  createRootSurfaceState,
+  mountRootSurface
+} from "./surface/root-surface.js";
+import { CANVAS_2D_BACKEND } from "./backend/canvas-2d-backend.js";
+import { createLayerSurface } from "./surface/resolve-surface.js";
+import { executeRender } from "./execute-render.js";
+import { update } from "./update.js";
+import {
+  queueBeginCommand,
+  registerRootInstance
+} from "./scheduler/realm-scheduler.js";
+function mountPibbl(canvas, element, config) {
+  if (GLOBAL_STATE.pibblInstances.has(canvas)) {
+    throw new Error("Pibbl is already mounted on this element.");
+  }
+  const mainTeardowns = new Teardowns();
+  const signal = config?.signal;
+  let ownedInstance;
+  const controller = {
+    dispose() {
+      const instance = ownedInstance;
+      if (!instance) {
+        return;
+      }
+      cleanupPibblInstance(instance);
+      ownedInstance = void 0;
+    }
+  };
+  const parent = config?.parent;
+  const rootCanvas = isHTMLCanvas(canvas) ? canvas : void 0;
+  const surface = parent || !rootCanvas ? config?.surface ? { kind: "layer", managed: true, snapshot: config.surface } : createLegacyLayerSurfaceState(canvas.width, canvas.height) : createRootSurfaceState(rootCanvas, config);
+  const parentInstance = parent ? GLOBAL_STATE.pibblInstances.get(parent) : void 0;
+  if (parent && !parentInstance) {
+    throw new Error("Parent Pibbl interaction root not found");
+  }
+  let pibblInstance;
+  const eventRoot = parentInstance?.eventRoot ?? createEventRoot(
+    rootCanvas,
+    mainTeardowns,
+    (type, event) => {
+      dispatchNativeEvent(pibblInstance, type, event);
+    }
+  );
+  pibblInstance = {
+    canvas,
+    controller,
+    root: element,
+    pendingRoot: NO_PENDING_ROOT,
+    pendingUpdateParents: false,
+    refs: /* @__PURE__ */ new Map(),
+    renderGeneration: 0,
+    renderSeenIds: /* @__PURE__ */ new Set(),
+    renderSeenKeys: /* @__PURE__ */ new Set(),
+    requestedRenderRevision: 0,
+    completedRenderRevision: 0,
+    renderTimestamp: 0,
+    mainTeardowns,
+    eventRoot,
+    regions: /* @__PURE__ */ new Set(),
+    paintEntries: /* @__PURE__ */ new Set(),
+    cursorDefaults: /* @__PURE__ */ new Set(),
+    interaction: {
+      hoveredRegion: void 0,
+      primaryDown: void 0,
+      primaryUp: void 0,
+      auxiliaryDown: /* @__PURE__ */ new Map(),
+      auxiliaryUp: /* @__PURE__ */ new Map(),
+      clickStreakTarget: void 0,
+      clickStreak: 0,
+      cursorRegion: void 0,
+      cursorDefault: void 0,
+      pointerCanvas: void 0,
+      cursorCanvas: void 0,
+      cursorStyle: void 0
+    },
+    interactionRoot: void 0,
+    parent,
+    eventParent: void 0,
+    focusParentBridge: void 0,
+    rootLayoutBox: Object.freeze({
+      x: 0,
+      y: 0,
+      width: surface.snapshot?.logicalWidth ?? (surface.kind === "root" && surface.config.mode === "fixed" ? surface.config.width : surface.kind === "root" ? surface.display.width : canvas.width),
+      height: surface.snapshot?.logicalHeight ?? (surface.kind === "root" && surface.config.mode === "fixed" ? surface.config.height : surface.kind === "root" ? surface.display.height : canvas.height)
+    }),
+    surface,
+    optionalServices: /* @__PURE__ */ new Map(),
+    backendDriver: config?.driver ?? CANVAS_2D_BACKEND
+  };
+  pibblInstance.interactionRoot = parent ? GLOBAL_STATE.pibblInstances.get(parent)?.interactionRoot : pibblInstance;
+  if (!pibblInstance.interactionRoot) throw new Error("Parent Pibbl interaction root not found");
+  if (!parent) {
+    eventRoot.rootInstance = pibblInstance;
+    eventRoot.onNodeRelease = (node) => releaseEventNodeState(pibblInstance, node);
+    eventRoot.onTargetUpdate = (target) => refreshInteractionCursor(pibblInstance, target);
+  }
+  ownedInstance = pibblInstance;
+  GLOBAL_STATE.pibblInstances.set(canvas, pibblInstance);
+  try {
+    if (config?.htmlOverlay) reserveHtmlOverlay(pibblInstance, config.htmlOverlay);
+    if (!parent && rootCanvas) {
+      mountRootSurface(pibblInstance, rootCanvas);
+    }
+    if (signal) {
+      const abortHandler = () => controller.dispose();
+      signal.addEventListener("abort", abortHandler, { once: true });
+      mainTeardowns.add(() => {
+        signal.removeEventListener("abort", abortHandler);
+      });
+    }
+    if (signal?.aborted) {
+      controller.dispose();
+    }
+  } catch (error) {
+    controller.dispose();
+    throw error;
+  }
+  if (!parent && GLOBAL_STATE.pibblInstances.get(canvas) === pibblInstance) {
+    registerRootInstance(pibblInstance);
+  }
+  return controller;
+}
+function mountBackendPibbl(canvas, root, options) {
+  const { logicalWidth, logicalHeight } = options;
+  const surface = createLayerSurface(
+    logicalWidth,
+    logicalHeight,
+    canvas.width / logicalWidth,
+    canvas.height / logicalHeight
+  );
+  const controller = mountPibbl(canvas, root, {
+    parent: options.parent,
+    surface,
+    driver: options.driver
+  });
+  const instance = GLOBAL_STATE.pibblInstances.get(canvas);
+  if (!instance) {
+    throw new Error("Pibbl backend mount did not retain its instance.");
+  }
+  const requireActiveInstance = () => {
+    if (instance.mainTeardowns.closed || GLOBAL_STATE.pibblInstances.get(canvas) !== instance) {
+      throw new Error("Pibbl backend mount is no longer active.");
+    }
+  };
+  let pendingFrame;
+  let pendingUpdateParents = false;
+  const cancelFrame = () => {
+    pendingFrame?.cancel();
+    pendingFrame = void 0;
+    pendingUpdateParents = false;
+  };
+  return Object.freeze({
+    canvas,
+    resize(nextLogicalWidth, nextLogicalHeight) {
+      requireActiveInstance();
+      const nextSurface = createLayerSurface(
+        nextLogicalWidth,
+        nextLogicalHeight,
+        canvas.width / nextLogicalWidth,
+        canvas.height / nextLogicalHeight
+      );
+      if (instance.surface.kind !== "layer") {
+        throw new Error("Pibbl backend mount does not own a managed layer surface.");
+      }
+      instance.surface.snapshot = nextSurface;
+      instance.surface.managed = true;
+      instance.rootLayoutBox = Object.freeze({
+        x: 0,
+        y: 0,
+        width: nextSurface.logicalWidth,
+        height: nextSurface.logicalHeight
+      });
+    },
+    render(nextRoot, timestamp) {
+      requireActiveInstance();
+      executeRender(canvas, timestamp, nextRoot, false);
+    },
+    requestFrame(updateParents) {
+      requireActiveInstance();
+      pendingUpdateParents ||= updateParents;
+      if (pendingFrame) return;
+      pendingFrame = queueBeginCommand(() => {
+        pendingFrame = void 0;
+        const updateParentsForFrame = pendingUpdateParents;
+        pendingUpdateParents = false;
+        requireActiveInstance();
+        if (updateParentsForFrame) {
+          update(canvas, void 0, true);
+        } else {
+          update(canvas);
+        }
+      });
+    },
+    dispose() {
+      cancelFrame();
+      controller.dispose();
+    }
+  });
+}
+function createEventRoot(canvas, teardowns, dispatch) {
+  const nativeListeners = canvas ? createNativeListenerHub(
+    canvas,
+    (definition, event) => dispatch(definition.type, event),
+    teardowns
+  ) : void 0;
+  const observers = new Map(
+    PIBBL_EVENT_TYPES.map((type) => [
+      type,
+      createNativeObserverSet(type, nativeListeners)
+    ])
+  );
+  return {
+    rootInstance: void 0,
+    canvas,
+    nativeListeners,
+    targets: /* @__PURE__ */ new Set(),
+    listenersByComponent: /* @__PURE__ */ new Map(),
+    observers,
+    pointerCaptures: /* @__PURE__ */ new Map(),
+    onNodeRelease: void 0,
+    onTargetUpdate: void 0
+  };
+}
+function createNativeObserverSet(type, nativeListeners) {
+  const observers = /* @__PURE__ */ new Set();
+  const originalAdd = observers.add;
+  const originalDelete = observers.delete;
+  const originalClear = observers.clear;
+  let release;
+  observers.add = ((observer) => {
+    const wasEmpty = observers.size === 0;
+    originalAdd.call(observers, observer);
+    if (wasEmpty) {
+      release = nativeListeners?.acquire(type);
+    }
+    return observers;
+  });
+  observers.delete = ((observer) => {
+    const deleted = originalDelete.call(observers, observer);
+    if (deleted && observers.size === 0) {
+      release?.();
+      release = void 0;
+    }
+    return deleted;
+  });
+  observers.clear = (() => {
+    if (observers.size > 0) {
+      originalClear.call(observers);
+      release?.();
+      release = void 0;
+    }
+  });
+  return observers;
+}
+function isHTMLCanvas(canvas) {
+  return typeof HTMLCanvasElement !== "undefined" && canvas instanceof HTMLCanvasElement;
+}
+export {
+  mountBackendPibbl,
+  mountPibbl
+};
+//# sourceMappingURL=mount-pibbl.js.map

package/dist/lib/mount-pibbl.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/mount-pibbl.ts"],
+  "sourcesContent": ["import { reserveHtmlOverlay } from './html/overlay-config.js';\nimport {\n  cleanupPibblInstance,\n  GLOBAL_STATE,\n  NO_PENDING_ROOT,\n} from './global-state.js';\nimport { PIBBL_EVENT_TYPES } from './events/event-definitions.js';\nimport {\n  dispatchNativeEvent,\n  refreshInteractionCursor,\n  releaseEventNodeState,\n} from './events/dispatch.js';\nimport { createNativeListenerHub } from './events/native-listener-hub.js';\nimport type { PibblEventType as DOMPibblEventType } from './events/types.js';\nimport { Teardowns } from './teardowns.js';\nimport {\n  Canvas,\n  PibblController,\n  PibblEventRoot,\n  PibblInstance,\n  PibblNativeObserver,\n  type PibblNode,\n} from './types.js';\nimport type { PibblConfig, PibblSurfaceSnapshot } from './surface/types.js';\nimport {\n  createLegacyLayerSurfaceState,\n  createRootSurfaceState,\n  mountRootSurface,\n} from './surface/root-surface.js';\nimport { CANVAS_2D_BACKEND } from './backend/canvas-2d-backend.js';\nimport type {\n  PibblBackendDriver,\n  PibblBackendMount,\n  PibblBackendMountOptions,\n} from './backend/types.js';\nimport { createLayerSurface } from './surface/resolve-surface.js';\nimport { executeRender } from './execute-render.js';\nimport { update } from './update.js';\nimport {\n  queueBeginCommand,\n  registerRootInstance,\n} from './scheduler/realm-scheduler.js';\nimport type { PibblBeginCommandHandle } from './scheduler/types.js';\n\ntype MountPibblConfig = PibblConfig & {\n  parent?: Canvas;\n  surface?: PibblSurfaceSnapshot;\n  driver?: PibblBackendDriver<unknown>;\n};\n\nexport function mountPibbl(\n  canvas: Canvas,\n  element: PibblNode,\n  config?: MountPibblConfig,\n): PibblController {\n  if (GLOBAL_STATE.pibblInstances.has(canvas)) {\n    throw new Error('Pibbl is already mounted on this element.');\n  }\n  const mainTeardowns = new Teardowns();\n  const signal = config?.signal;\n  let ownedInstance: PibblInstance | undefined;\n  const controller: PibblController = {\n    dispose(): void {\n      const instance = ownedInstance;\n      if (!instance) {\n        return;\n      }\n      cleanupPibblInstance(instance);\n      ownedInstance = undefined;\n    },\n  };\n  const parent = config?.parent;\n  const rootCanvas = isHTMLCanvas(canvas) ? canvas : undefined;\n  const surface = parent || !rootCanvas ?\n    config?.surface ?\n      { kind: 'layer' as const, managed: true, snapshot: config.surface } :\n      createLegacyLayerSurfaceState(canvas.width, canvas.height) :\n    createRootSurfaceState(rootCanvas, config);\n\n  const parentInstance = parent ? GLOBAL_STATE.pibblInstances.get(parent) : undefined;\n  if (parent && !parentInstance) {\n    throw new Error('Parent Pibbl interaction root not found');\n  }\n\n  let pibblInstance: PibblInstance;\n  const eventRoot: PibblEventRoot = parentInstance?.eventRoot ?? createEventRoot(\n    rootCanvas,\n    mainTeardowns,\n    (type, event) => {\n      dispatchNativeEvent(pibblInstance, type, event);\n    },\n  );\n\n  pibblInstance = {\n    canvas,\n    controller,\n    root: element,\n    pendingRoot: NO_PENDING_ROOT,\n    pendingUpdateParents: false,\n    refs: new Map(),\n    renderGeneration: 0,\n    renderSeenIds: new Set(),\n    renderSeenKeys: new Set(),\n    requestedRenderRevision: 0,\n    completedRenderRevision: 0,\n    renderTimestamp: 0,\n    mainTeardowns,\n    eventRoot,\n    regions: new Set(),\n    paintEntries: new Set(),\n    cursorDefaults: new Set(),\n    interaction: {\n      hoveredRegion: undefined,\n      primaryDown: undefined,\n      primaryUp: undefined,\n      auxiliaryDown: new Map(),\n      auxiliaryUp: new Map(),\n      clickStreakTarget: undefined,\n      clickStreak: 0,\n      cursorRegion: undefined,\n      cursorDefault: undefined,\n      pointerCanvas: undefined,\n      cursorCanvas: undefined,\n      cursorStyle: undefined,\n    },\n    interactionRoot: undefined,\n    parent,\n    eventParent: undefined,\n    focusParentBridge: undefined,\n    rootLayoutBox: Object.freeze({\n      x: 0,\n      y: 0,\n      width: surface.snapshot?.logicalWidth ??\n        (surface.kind === 'root' && surface.config.mode === 'fixed' ?\n          surface.config.width :\n          surface.kind === 'root' ? surface.display.width : canvas.width),\n      height: surface.snapshot?.logicalHeight ??\n        (surface.kind === 'root' && surface.config.mode === 'fixed' ?\n          surface.config.height :\n          surface.kind === 'root' ? surface.display.height : canvas.height),\n    }),\n    surface,\n    optionalServices: new Map(),\n    backendDriver: config?.driver ?? CANVAS_2D_BACKEND,\n  };\n  pibblInstance.interactionRoot = parent ?\n      GLOBAL_STATE.pibblInstances.get(parent)?.interactionRoot :\n    pibblInstance;\n  if (!pibblInstance.interactionRoot) throw new Error('Parent Pibbl interaction root not found');\n  if (!parent) {\n    eventRoot.rootInstance = pibblInstance;\n    eventRoot.onNodeRelease = node => releaseEventNodeState(pibblInstance, node);\n    eventRoot.onTargetUpdate = target =>\n      refreshInteractionCursor(pibblInstance, target);\n  }\n  ownedInstance = pibblInstance;\n  GLOBAL_STATE.pibblInstances.set(canvas, pibblInstance);\n\n  try {\n    if (config?.htmlOverlay) reserveHtmlOverlay(pibblInstance, config.htmlOverlay);\n    if (!parent && rootCanvas) {\n      mountRootSurface(pibblInstance, rootCanvas);\n    }\n    if (signal) {\n      const abortHandler = () => controller.dispose();\n      signal.addEventListener('abort', abortHandler, { once: true });\n      mainTeardowns.add(() => {\n        signal.removeEventListener('abort', abortHandler);\n      });\n    }\n\n    if (signal?.aborted) {\n      controller.dispose();\n    }\n  } catch (error) {\n    controller.dispose();\n    throw error;\n  }\n\n  if (!parent && GLOBAL_STATE.pibblInstances.get(canvas) === pibblInstance) {\n    registerRootInstance(pibblInstance);\n  }\n\n  return controller;\n}\n\n/**\n * Mounts a private official-backend Pibbl child under an existing Pibbl root.\n *\n * @param canvas - Host canvas for this backend mount. See {@link Canvas}.\n * @param root - Initial Pibbl node tree. See {@link PibblNode}.\n * @param options - Backend driver and mount configuration. See {@link PibblBackendMountOptions}.\n * @returns Mount controls for rendering, resizing, scheduling, and disposal. See\n * {@link PibblBackendMount} .\n *\n * @see {@link Canvas}\n * @see {@link PibblNode}\n * @see {@link PibblBackendMountOptions}\n * @see {@link PibblBackendMount}\n */\nexport function mountBackendPibbl<E>(\n  canvas: Canvas,\n  root: PibblNode,\n  options: PibblBackendMountOptions<E>,\n): PibblBackendMount {\n  const { logicalWidth, logicalHeight } = options;\n  const surface = createLayerSurface(\n    logicalWidth,\n    logicalHeight,\n    canvas.width / logicalWidth,\n    canvas.height / logicalHeight,\n  );\n  const controller = mountPibbl(canvas, root, {\n    parent: options.parent,\n    surface,\n    driver: options.driver as PibblBackendDriver<unknown>,\n  });\n  const instance = GLOBAL_STATE.pibblInstances.get(canvas);\n  if (!instance) {\n    throw new Error('Pibbl backend mount did not retain its instance.');\n  }\n  const requireActiveInstance = () => {\n    if (\n      instance.mainTeardowns.closed ||\n      GLOBAL_STATE.pibblInstances.get(canvas) !== instance\n    ) {\n      throw new Error('Pibbl backend mount is no longer active.');\n    }\n  };\n  let pendingFrame: PibblBeginCommandHandle | undefined;\n  let pendingUpdateParents = false;\n  const cancelFrame = () => {\n    pendingFrame?.cancel();\n    pendingFrame = undefined;\n    pendingUpdateParents = false;\n  };\n  return Object.freeze({\n    canvas,\n    resize(nextLogicalWidth: number, nextLogicalHeight: number): void {\n      requireActiveInstance();\n      const nextSurface = createLayerSurface(\n        nextLogicalWidth,\n        nextLogicalHeight,\n        canvas.width / nextLogicalWidth,\n        canvas.height / nextLogicalHeight,\n      );\n      if (instance.surface.kind !== 'layer') {\n        throw new Error('Pibbl backend mount does not own a managed layer surface.');\n      }\n      instance.surface.snapshot = nextSurface;\n      instance.surface.managed = true;\n      instance.rootLayoutBox = Object.freeze({\n        x: 0,\n        y: 0,\n        width: nextSurface.logicalWidth,\n        height: nextSurface.logicalHeight,\n      });\n    },\n    render(nextRoot: PibblNode, timestamp: number): void {\n      requireActiveInstance();\n      executeRender(canvas, timestamp, nextRoot, false);\n    },\n    requestFrame(updateParents: boolean): void {\n      requireActiveInstance();\n      pendingUpdateParents ||= updateParents;\n      if (pendingFrame) return;\n      pendingFrame = queueBeginCommand(() => {\n        pendingFrame = undefined;\n        const updateParentsForFrame = pendingUpdateParents;\n        pendingUpdateParents = false;\n        requireActiveInstance();\n        if (updateParentsForFrame) {\n          update(canvas, undefined, true);\n        } else {\n          update(canvas);\n        }\n      });\n    },\n    dispose(): void {\n      cancelFrame();\n      controller.dispose();\n    },\n  });\n}\n\nfunction createEventRoot(\n  canvas: HTMLCanvasElement | undefined,\n  teardowns: Teardowns,\n  dispatch: (type: DOMPibblEventType, event: Event) => void,\n): PibblEventRoot {\n  const nativeListeners = canvas ? createNativeListenerHub(\n    canvas,\n    (definition, event) => dispatch(definition.type, event),\n    teardowns,\n  ) : undefined;\n  const observers = new Map<DOMPibblEventType, Set<PibblNativeObserver>>(\n    PIBBL_EVENT_TYPES.map(type => [\n      type,\n      createNativeObserverSet(type, nativeListeners),\n    ]),\n  );\n  return {\n    rootInstance: undefined,\n    canvas,\n    nativeListeners,\n    targets: new Set(),\n    listenersByComponent: new Map(),\n    observers,\n    pointerCaptures: new Map(),\n    onNodeRelease: undefined,\n    onTargetUpdate: undefined,\n  };\n}\n\nfunction createNativeObserverSet(\n  type: DOMPibblEventType,\n  nativeListeners: PibblEventRoot['nativeListeners'],\n): Set<PibblNativeObserver> {\n  const observers = new Set<PibblNativeObserver>();\n  const originalAdd = observers.add;\n  const originalDelete = observers.delete;\n  const originalClear = observers.clear;\n  let release: (() => void) | undefined;\n\n  observers.add = ((observer) => {\n    const wasEmpty = observers.size === 0;\n    originalAdd.call(observers, observer);\n    if (wasEmpty) {\n      release = nativeListeners?.acquire(type);\n    }\n    return observers;\n  }) as typeof observers.add;\n  observers.delete = ((observer) => {\n    const deleted = originalDelete.call(observers, observer);\n    if (deleted && observers.size === 0) {\n      release?.();\n      release = undefined;\n    }\n    return deleted;\n  }) as typeof observers.delete;\n  observers.clear = (() => {\n    if (observers.size > 0) {\n      originalClear.call(observers);\n      release?.();\n      release = undefined;\n    }\n  }) as typeof observers.clear;\n  return observers;\n}\n\nfunction isHTMLCanvas(canvas: Canvas): canvas is HTMLCanvasElement {\n  return typeof HTMLCanvasElement !== 'undefined' && canvas instanceof HTMLCanvasElement;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/optional-services.d.ts

@@ -0,0 +1,8 @@
+import type { PibblInstance } from './types.js';
+export interface OptionalService {
+    dispose(): void;
+    beginRender?(): void;
+    endRender?(success: boolean): void;
+}
+/** @internal Lazily installs an optional feature service on one Pibbl instance. */
+export declare function getOptionalService<T extends OptionalService>(instance: PibblInstance, key: symbol, create: () => T): T;

package/dist/lib/optional-services.js

@@ -0,0 +1,11 @@
+function getOptionalService(instance, key, create) {
+  const existing = instance.optionalServices.get(key);
+  if (existing) return existing;
+  const service = create();
+  instance.optionalServices.set(key, service);
+  return service;
+}
+export {
+  getOptionalService
+};
+//# sourceMappingURL=optional-services.js.map

package/dist/lib/optional-services.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/optional-services.ts"],
+  "sourcesContent": ["import type { PibblInstance } from './types.js';\n\nexport interface OptionalService {\n  dispose(): void;\n  beginRender?(): void;\n  endRender?(success: boolean): void;\n}\n\n/** @internal Lazily installs an optional feature service on one Pibbl instance. */\nexport function getOptionalService<T extends OptionalService>(instance: PibblInstance, key: symbol, create: () => T): T {\n  const existing = instance.optionalServices.get(key) as T | undefined;\n  if (existing) return existing;\n  const service = create();\n  instance.optionalServices.set(key, service);\n  return service;\n}\n"],
+  "mappings": "AASO,SAAS,mBAA8C,UAAyB,KAAa,QAAoB;AACtH,QAAM,WAAW,SAAS,iBAAiB,IAAI,GAAG;AAClD,MAAI,SAAU,QAAO;AACrB,QAAM,UAAU,OAAO;AACvB,WAAS,iBAAiB,IAAI,KAAK,OAAO;AAC1C,SAAO;AACT;",
+  "names": []
+}

package/dist/lib/pibbl.d.ts

@@ -0,0 +1,17 @@
+import { PibblController, type PibblNode } from './types.js';
+import type { PibblConfig } from './surface/types.js';
+/**
+ * Mounts or updates a canvas render component on a given HTMLCanvasElement.
+ * The first mount captures the surface configuration; later calls update only
+ * the root element until that controller is disposed.
+ * @param canvas The canvas to render on
+ * @param element The Pibbl element to render
+ * @param config The mount lifetime, logical viewport, fit, and pixel density. See
+ * {@link PibblConfig} .
+ * @returns The stable {@link PibblController} for this canvas; dispose it to release the mount.
+ *
+ * @see {@link PibblNode}
+ * @see {@link PibblConfig}
+ * @see {@link PibblController}
+ */
+export declare function pibbl(canvas: HTMLCanvasElement, element: PibblNode, config?: PibblConfig): PibblController;

package/dist/lib/pibbl.js

@@ -0,0 +1,21 @@
+import { GLOBAL_STATE } from "./global-state.js";
+import { mountPibbl } from "./mount-pibbl.js";
+import { assertCompatibleRootNode } from "./element/children.js";
+import { update } from "./update.js";
+function pibbl(canvas, element, config) {
+  assertCompatibleRootNode(element);
+  const mountedInstance = GLOBAL_STATE.pibblInstances.get(canvas);
+  if (mountedInstance) {
+    update(canvas, element);
+    return mountedInstance.controller;
+  }
+  const controller = mountPibbl(canvas, element, config);
+  if (GLOBAL_STATE.pibblInstances.has(canvas)) {
+    update(canvas, element);
+  }
+  return controller;
+}
+export {
+  pibbl
+};
+//# sourceMappingURL=pibbl.js.map

package/dist/lib/pibbl.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/pibbl.ts"],
+  "sourcesContent": ["import { GLOBAL_STATE } from './global-state.js';\nimport { mountPibbl } from './mount-pibbl.js';\nimport { assertCompatibleRootNode } from './element/children.js';\nimport { PibblController, type PibblNode } from './types.js';\nimport { update } from './update.js';\nimport type { PibblConfig } from './surface/types.js';\n\n/**\n * Mounts or updates a canvas render component on a given HTMLCanvasElement.\n * The first mount captures the surface configuration; later calls update only\n * the root element until that controller is disposed.\n * @param canvas The canvas to render on\n * @param element The Pibbl element to render\n * @param config The mount lifetime, logical viewport, fit, and pixel density. See\n * {@link PibblConfig} .\n * @returns The stable {@link PibblController} for this canvas; dispose it to release the mount.\n *\n * @see {@link PibblNode}\n * @see {@link PibblConfig}\n * @see {@link PibblController}\n */\nexport function pibbl(\n  canvas: HTMLCanvasElement,\n  element: PibblNode,\n  config?: PibblConfig,\n): PibblController {\n  assertCompatibleRootNode(element);\n  const mountedInstance = GLOBAL_STATE.pibblInstances.get(canvas);\n  if (mountedInstance) {\n    update(canvas, element);\n    return mountedInstance.controller;\n  }\n\n  const controller = mountPibbl(canvas, element, config);\n  if (GLOBAL_STATE.pibblInstances.has(canvas)) {\n    update(canvas, element);\n  }\n  return controller;\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAC7B,SAAS,kBAAkB;AAC3B,SAAS,gCAAgC;AAEzC,SAAS,cAAc;AAiBhB,SAAS,MACd,QACA,SACA,QACiB;AACjB,2BAAyB,OAAO;AAChC,QAAM,kBAAkB,aAAa,eAAe,IAAI,MAAM;AAC9D,MAAI,iBAAiB;AACnB,WAAO,QAAQ,OAAO;AACtB,WAAO,gBAAgB;AAAA,EACzB;AAEA,QAAM,aAAa,WAAW,QAAQ,SAAS,MAAM;AACrD,MAAI,aAAa,eAAe,IAAI,MAAM,GAAG;AAC3C,WAAO,QAAQ,OAAO;AAAA,EACxB;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/lib/primitive-presentation.d.ts

@@ -0,0 +1,24 @@
+import { getPrimitivePresentation, setPrimitivePresentation } from './element/metadata.js';
+export interface PrimitivePresentation {
+    readonly transform?: DOMMatrix;
+    readonly clip?: {
+        readonly path: Path2D;
+        readonly svgPath?: string;
+        readonly fillRule: CanvasFillRule;
+    };
+}
+export interface GroupTransformStyle {
+    readonly scaleX?: number;
+    readonly scaleY?: number;
+    readonly rotationDegrees?: number;
+    readonly rotationOrigin?: readonly [number, number];
+    readonly translateX?: number;
+    readonly translateY?: number;
+    readonly skewX?: number;
+    readonly skewY?: number;
+}
+export declare function createGroupTransform(style: Readonly<GroupTransformStyle>): DOMMatrix;
+export declare function enterPrimitivePresentation(presentation: Readonly<PrimitivePresentation> | undefined, options?: Readonly<{
+    deferPaint?: boolean;
+}>): () => void;
+export { getPrimitivePresentation, setPrimitivePresentation };