@pibbl/core 0.0.1

package/dist/lib/element/resolve-primitive-inputs.js

@@ -0,0 +1,83 @@
+import { resolveResponsiveStyle, preparedStyleValue } from "../style/responsive.js";
+import {
+  getPrimitiveProgramProps,
+  getOpaquePrimitiveProps,
+  getSpecifiedStyle
+} from "./metadata.js";
+import {
+  isSignal,
+  recordPlainInputResolution,
+  recordShallowInputCopy,
+  recordSignalInputResolution
+} from "../signals/graph.js";
+function resolvePrimitiveInputs(element, definition, prepared, basis) {
+  const rawProps = getPrimitiveProgramProps(element);
+  const preserve = definition.preserveSignalProps;
+  let programProps;
+  for (const key in rawProps) {
+    const value = rawProps[key];
+    if (key === "children" || preserve?.includes(key) || getOpaquePrimitiveProps(element.type)?.includes(key)) {
+      if (programProps !== void 0) programProps[key] = value;
+      continue;
+    }
+    if (isSignal(value)) {
+      recordSignalInputResolution();
+      if (programProps === void 0) {
+        programProps = { ...rawProps };
+        recordShallowInputCopy();
+      }
+      programProps[key] = value.get();
+    } else {
+      recordPlainInputResolution();
+      if (programProps !== void 0) programProps[key] = value;
+    }
+  }
+  return {
+    props: programProps ?? rawProps,
+    style: prepared ? prepared.style : resolvePrimitiveStyleInput(
+      getSpecifiedStyle(element),
+      element,
+      basis,
+      "value"
+    )
+  };
+}
+function resolvePrimitiveStyleInput(input, element, basis, mode = "preparation") {
+  let style = input;
+  if (isSignal(style)) {
+    recordSignalInputResolution();
+    style = style.get();
+  } else if (style !== void 0) {
+    recordPlainInputResolution();
+  }
+  if (style === void 0) return void 0;
+  if (style === null || typeof style !== "object") {
+    return style;
+  }
+  const source = style;
+  if (source.when !== void 0) {
+    const prepared = resolveResponsiveStyle(source, element, basis);
+    return mode === "value" ? preparedStyleValue(prepared) : prepared;
+  }
+  let resolved;
+  for (const key in source) {
+    if (key === "custom") continue;
+    const value = source[key];
+    if (isSignal(value)) {
+      recordSignalInputResolution();
+      if (resolved === void 0) {
+        resolved = { ...source };
+        recordShallowInputCopy();
+      }
+      resolved[key] = value.get();
+    } else {
+      recordPlainInputResolution();
+    }
+  }
+  return resolved ?? source;
+}
+export {
+  resolvePrimitiveInputs,
+  resolvePrimitiveStyleInput
+};
+//# sourceMappingURL=resolve-primitive-inputs.js.map

package/dist/lib/element/resolve-primitive-inputs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/element/resolve-primitive-inputs.ts"],
+  "sourcesContent": ["import { resolveResponsiveStyle, preparedStyleValue, type ResponsiveStylePreparation, type QueryBasis } from '../style/responsive.js';\nimport {\n  getPrimitiveProgramProps,\n  getOpaquePrimitiveProps,\n  getSpecifiedStyle,\n  type PrimitiveDefinition,\n} from './metadata.js';\nimport type { PibblElement } from './types.js';\nimport {\n  isSignal,\n  recordPlainInputResolution,\n  recordShallowInputCopy,\n  recordSignalInputResolution,\n} from '../signals/graph.js';\n\nexport interface ResolvedPrimitiveInputs {\n  readonly props: Readonly<Record<PropertyKey, unknown>>;\n  readonly style: Readonly<Record<PropertyKey, unknown>> | undefined;\n}\n\nexport function resolvePrimitiveInputs(\n  element: PibblElement<any>,\n  definition: PrimitiveDefinition,\n  prepared?: { style: Readonly<Record<PropertyKey, unknown>> },\n  basis?: QueryBasis,\n): ResolvedPrimitiveInputs {\n  const rawProps = getPrimitiveProgramProps(element) as Readonly<\n    Record<PropertyKey, unknown>\n  >;\n  const preserve = definition.preserveSignalProps as\n    readonly PropertyKey[] | undefined;\n  let programProps: Record<PropertyKey, unknown> | undefined;\n\n  for (const key in rawProps) {\n    const value = rawProps[key];\n    if (key === 'children' || preserve?.includes(key) || getOpaquePrimitiveProps(element.type)?.includes(key)) {\n      if (programProps !== undefined) programProps[key] = value;\n      continue;\n    }\n    if (isSignal(value)) {\n      recordSignalInputResolution();\n      if (programProps === undefined) {\n        programProps = { ...rawProps };\n        recordShallowInputCopy();\n      }\n      programProps[key] = value.get();\n    } else {\n      recordPlainInputResolution();\n      if (programProps !== undefined) programProps[key] = value;\n    }\n  }\n\n  return {\n    props: programProps ?? rawProps,\n    style: prepared ? prepared.style : resolvePrimitiveStyleInput(\n      getSpecifiedStyle(element), element, basis, 'value',\n    ),\n  };\n}\n\nexport function resolvePrimitiveStyleInput(\n  input: unknown,\n  element: PibblElement<any> | undefined,\n  basis: QueryBasis | undefined,\n  mode: 'value',\n): Readonly<Record<PropertyKey, unknown>> | undefined;\nexport function resolvePrimitiveStyleInput(\n  input: unknown,\n  element?: PibblElement<any>,\n  basis?: QueryBasis,\n): Readonly<Record<PropertyKey, unknown>> | ResponsiveStylePreparation | undefined;\nexport function resolvePrimitiveStyleInput(\n  input: unknown,\n  element?: PibblElement<any>,\n  basis?: QueryBasis,\n  mode: 'value' | 'preparation' = 'preparation',\n): Readonly<Record<PropertyKey, unknown>> | ResponsiveStylePreparation | undefined {\n  let style = input;\n  if (isSignal(style)) {\n    recordSignalInputResolution();\n    style = style.get();\n  } else if (style !== undefined) {\n    recordPlainInputResolution();\n  }\n  if (style === undefined) return undefined;\n  if (style === null || typeof style !== 'object') {\n    return style as Readonly<Record<PropertyKey, unknown>>;\n  }\n\n  const source = style as Readonly<Record<PropertyKey, unknown>>;\n  if (source.when !== undefined) {\n    const prepared = resolveResponsiveStyle(source, element, basis);\n    return mode === 'value' ? preparedStyleValue(prepared) : prepared;\n  }\n  let resolved: Record<PropertyKey, unknown> | undefined;\n  for (const key in source) {\n    if (key === 'custom') continue;\n    const value = source[key];\n    if (isSignal(value)) {\n      recordSignalInputResolution();\n      if (resolved === undefined) {\n        resolved = { ...source };\n        recordShallowInputCopy();\n      }\n      resolved[key] = value.get();\n    } else {\n      recordPlainInputResolution();\n    }\n  }\n  return resolved ?? source;\n}\n"],
+  "mappings": "AAAA,SAAS,wBAAwB,0BAA4E;AAC7G;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAOA,SAAS,uBACd,SACA,YACA,UACA,OACyB;AACzB,QAAM,WAAW,yBAAyB,OAAO;AAGjD,QAAM,WAAW,WAAW;AAE5B,MAAI;AAEJ,aAAW,OAAO,UAAU;AAC1B,UAAM,QAAQ,SAAS,GAAG;AAC1B,QAAI,QAAQ,cAAc,UAAU,SAAS,GAAG,KAAK,wBAAwB,QAAQ,IAAI,GAAG,SAAS,GAAG,GAAG;AACzG,UAAI,iBAAiB,OAAW,cAAa,GAAG,IAAI;AACpD;AAAA,IACF;AACA,QAAI,SAAS,KAAK,GAAG;AACnB,kCAA4B;AAC5B,UAAI,iBAAiB,QAAW;AAC9B,uBAAe,EAAE,GAAG,SAAS;AAC7B,+BAAuB;AAAA,MACzB;AACA,mBAAa,GAAG,IAAI,MAAM,IAAI;AAAA,IAChC,OAAO;AACL,iCAA2B;AAC3B,UAAI,iBAAiB,OAAW,cAAa,GAAG,IAAI;AAAA,IACtD;AAAA,EACF;AAEA,SAAO;AAAA,IACL,OAAO,gBAAgB;AAAA,IACvB,OAAO,WAAW,SAAS,QAAQ;AAAA,MACjC,kBAAkB,OAAO;AAAA,MAAG;AAAA,MAAS;AAAA,MAAO;AAAA,IAC9C;AAAA,EACF;AACF;AAaO,SAAS,2BACd,OACA,SACA,OACA,OAAgC,eACiD;AACjF,MAAI,QAAQ;AACZ,MAAI,SAAS,KAAK,GAAG;AACnB,gCAA4B;AAC5B,YAAQ,MAAM,IAAI;AAAA,EACpB,WAAW,UAAU,QAAW;AAC9B,+BAA2B;AAAA,EAC7B;AACA,MAAI,UAAU,OAAW,QAAO;AAChC,MAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;AAC/C,WAAO;AAAA,EACT;AAEA,QAAM,SAAS;AACf,MAAI,OAAO,SAAS,QAAW;AAC7B,UAAM,WAAW,uBAAuB,QAAQ,SAAS,KAAK;AAC9D,WAAO,SAAS,UAAU,mBAAmB,QAAQ,IAAI;AAAA,EAC3D;AACA,MAAI;AACJ,aAAW,OAAO,QAAQ;AACxB,QAAI,QAAQ,SAAU;AACtB,UAAM,QAAQ,OAAO,GAAG;AACxB,QAAI,SAAS,KAAK,GAAG;AACnB,kCAA4B;AAC5B,UAAI,aAAa,QAAW;AAC1B,mBAAW,EAAE,GAAG,OAAO;AACvB,+BAAuB;AAAA,MACzB;AACA,eAAS,GAAG,IAAI,MAAM,IAAI;AAAA,IAC5B,OAAO;AACL,iCAA2B;AAAA,IAC7B;AAAA,EACF;AACA,SAAO,YAAY;AACrB;",
+  "names": []
+}

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

@@ -0,0 +1,123 @@
+import type { defineRenderLayer } from "../render-layer/define-render-layer.js";
+import type { measureElement } from "../layout/measure.js";
+import type { createElement } from "./create-element.js";
+import type { definePrimitive } from "../define-primitive.js";
+import type { TextProps } from "../components/text.js";
+import type { SignalValue } from '../signals/types.js';
+declare const pibblElementTypeBrand: unique symbol;
+declare const pibblPrimitiveComponentBrand: unique symbol;
+/**
+ * A stable sibling identity used when reconciling keyed elements.
+ *
+ * @see {@link createElement}
+ * @see {@link PibblElement}
+ */
+export type PibblKey = string | number;
+/**
+ * A child value that intentionally contributes no rendered output.
+ *
+ * @see {@link PibblNode}
+ */
+export type PibblEmptyNode = false | true | null | undefined | '' | 0;
+/**
+ * A textual child accepted by the Text primitive.
+ *
+ * @see {@link PibblTextInput}
+ */
+export type PibblTextChild = string | number | boolean | null | undefined | readonly PibblTextChild[] | Iterable<PibblTextChild>;
+/**
+ * A branded element descriptor containing component identity, props, and an optional reconciliation
+ * key.
+ *
+ * @see {@link PibblElementType}
+ * @see {@link PibblNode}
+ * @see {@link measureElement}
+ * @see {@link createElement}
+ */
+export interface PibblElement<P = unknown> {
+    readonly [pibblElementTypeBrand]: true;
+    /** Component identity evaluated when this element is rendered. See {@link PibblElementType}. */
+    readonly type: PibblElementType<P>;
+    /** Component props supplied to evaluation or measurement. See {@link PibblElement}. */
+    readonly props: Readonly<P>;
+    /** Stable identity used by the containing protocol. See {@link PibblElement}. */
+    readonly key?: string;
+}
+/**
+ * Recursive synchronous render output, including elements and empty child values.
+ *
+ * @see {@link PibblElement}
+ * @see {@link PibblEmptyNode}
+ * @see {@link PibblNodeInput}
+ */
+export type PibblNode = PibblElement<any> | PibblEmptyNode | readonly PibblNode[] | Iterable<PibblNode>;
+/**
+ * An authored node input that may be supplied by a signal.
+ *
+ * @see {@link SignalValue}
+ * @see {@link PibblNode}
+ * @see {@link PibblContainerChild}
+ * @see {@link PibblRenderResult}
+ */
+export type PibblNodeInput = SignalValue<PibblNode> | readonly PibblNodeInput[] | Iterable<PibblNodeInput>;
+/**
+ * Literal or signal-supplied text content for the Text primitive.
+ *
+ * @see {@link SignalValue}
+ * @see {@link PibblTextChild}
+ * @see {@link TextProps}
+ */
+export type PibblTextInput = SignalValue<PibblTextChild> | readonly PibblTextInput[] | Iterable<PibblTextInput>;
+/**
+ * A recursive child value accepted by a Pibbl container.
+ *
+ * @see {@link PibblNodeInput}
+ */
+export type PibblContainerChild = PibblNodeInput;
+/**
+ * The supported synchronous return value of a Pibbl component.
+ *
+ * @see {@link PibblNodeInput}
+ * @see {@link PibblComponent}
+ */
+export type PibblRenderResult = PibblNodeInput | void;
+/**
+ * A synchronous function that receives props and returns Pibbl nodes.
+ *
+ * @param props - Authored component properties supplied by Pibbl.
+ * @returns Synchronous Pibbl render output. See {@link PibblRenderResult}.
+ *
+ * @see {@link PibblRenderResult}
+ * @see {@link PibblElementType}
+ * @see {@link PibblPrimitiveComponent}
+ * @see {@link defineRenderLayer}
+ */
+export type PibblComponent<P = Record<string, never>> = (props: P) => PibblRenderResult;
+/**
+ * A branded primitive component with separate authored-input and resolved-prop types.
+ *
+ * @see {@link PibblComponent}
+ * @see {@link PrimitiveInputOf}
+ * @see {@link definePrimitive}
+ */
+export type PibblPrimitiveComponent<P = Record<string, never>, I = P> = PibblComponent<I> & {
+    readonly [pibblPrimitiveComponentBrand]: {
+        readonly input: I;
+        readonly programProps: P;
+    };
+};
+/**
+ * Extracts the authored-input type from a branded primitive component.
+ *
+ * @see {@link PibblPrimitiveComponent}
+ */
+export type PrimitiveInputOf<C> = C extends PibblPrimitiveComponent<any, infer I> ? I : never;
+/**
+ * A component or fragment identity that can be used to construct a Pibbl element.
+ *
+ * @see {@link PibblComponent}
+ * @see {@link PibblElement}
+ * @see {@link createElement}
+ */
+export type PibblElementType<P = any> = PibblComponent<P>;
+export {};

package/dist/lib/element-enhancers.d.ts

@@ -0,0 +1,134 @@
+import { type PibblElementSource } from './element/metadata.js';
+import type { PibblComponentRefs, PibblElement, PibblInstance } from './types.js';
+import type { PibblPresentationTransformLineage } from './global-state.js';
+/**
+ * Resolved primitive inputs and transform lineage supplied to an official attachment integration.
+ *
+ * @see {@link PibblElementSource}
+ * @see {@link PibblInternalMountedPropAttachment}
+ */
+export interface PibblInternalPrimitiveAttachmentInput {
+    /**
+     * Component function owning the primitive attachment. See
+     * {@link PibblInternalPrimitiveAttachmentInput}.
+     */
+    readonly componentType: Function;
+    /** Component name retained for diagnostics. See {@link PibblInternalPrimitiveAttachmentInput}. */
+    readonly componentName: string;
+    /**
+     * Component props supplied to evaluation or measurement. See
+     * {@link PibblInternalPrimitiveAttachmentInput}.
+     */
+    readonly props: Readonly<Record<PropertyKey, unknown>>;
+    /**
+     * Declared presentation and layout properties. See {@link PibblInternalPrimitiveAttachmentInput}.
+     */
+    readonly style: Readonly<Record<PropertyKey, unknown>>;
+    /** Authoring source location retained for diagnostics. See {@link PibblElementSource}. */
+    readonly source: PibblElementSource | undefined;
+    /** World transform at the primitive's parent. See {@link PibblInternalPrimitiveAttachmentInput}. */
+    readonly parentWorldTransform: DOMMatrix;
+    /** Exact Pibbl-owned transform lineage at this primitive's parent. */
+    readonly presentationTransformLineage: PibblPresentationTransformLineage | undefined;
+    /** A direct Canvas transform occurred outside the tracked Pibbl lineage. */
+    readonly hasUntrackedCanvasTransform: boolean;
+}
+/**
+ * Mount-owned primitive attachment with explicit update and teardown semantics.
+ *
+ * @see {@link PibblInternalPrimitiveAttachmentInput}
+ * @see {@link pibblInternalCreatePropAttachment}
+ */
+export interface PibblInternalMountedPropAttachment {
+    /**
+     * Updates the mounted attachment using the latest resolved primitive inputs. See
+     * {@link PibblInternalMountedPropAttachment}.
+     * @param value - Latest attachment descriptor supplied by the component.
+     */
+    update(value: unknown): void;
+    /**
+     * Enters the attachment's scope before primitive evaluation. See
+     * {@link PibblInternalMountedPropAttachment}.
+     */
+    enter(): void;
+    /**
+     * Prepares the attachment against the primitive's resolved inputs. See
+     * {@link PibblInternalMountedPropAttachment}.
+     * @param input - Primitive props, style, and geometry for attachment preparation. See
+     * {@link PibblInternalPrimitiveAttachmentInput} .
+     * @returns An optional presentation transform for the primitive.
+     */
+    preparePrimitive(input: PibblInternalPrimitiveAttachmentInput): Readonly<{
+        /**
+         * Transform applied to the primitive's presented Canvas geometry. See
+         * {@link PibblInternalMountedPropAttachment}.
+         */
+        readonly presentationTransform2D?: DOMMatrix;
+    }> | void;
+    /**
+     * Restores the surrounding scope after primitive evaluation. See
+     * {@link PibblInternalMountedPropAttachment}.
+     * @param success - Whether the attached component completed successfully.
+     */
+    exit(success: boolean): void;
+    /**
+     * Releases resources owned by this mounted object. See {@link PibblInternalMountedPropAttachment}
+     * .
+     */
+    dispose(): void;
+}
+export interface PibblElementEnhancerDescriptor {
+    readonly key: symbol;
+    mount(context: {
+        readonly component: PibblComponentRefs<any>;
+        readonly instance: PibblInstance;
+    }): PibblMountedElementEnhancer;
+}
+export interface PibblMountedElementEnhancer {
+    update(next: PibblElementEnhancerDescriptor): void;
+    enter(): void;
+    preparePrimitive?(input: PibblInternalPrimitiveAttachmentInput): Readonly<{
+        readonly presentationTransform2D?: DOMMatrix;
+    }> | void;
+    exit(success: boolean): void;
+    dispose(): void;
+}
+interface PibblMountedElementEnhancerEntry {
+    readonly key: symbol;
+    readonly mounted: PibblMountedElementEnhancer;
+}
+/** @internal Adds private metadata without introducing a component boundary. */
+export declare function appendElementEnhancer<P>(element: PibblElement<P>, descriptor: PibblElementEnhancerDescriptor): PibblElement<P>;
+/**
+ * Registers one closed official-package attachment without mutating its public value.
+ *
+ * @param property - Reserved prop name receiving the attachment.
+ * @param publicValue - Public descriptor exposed to component authors.
+ * @param mount - Factory creating the mounted attachment lifetime. See
+ * {@link PibblInternalMountedPropAttachment} .
+ * @returns The public descriptor associated with the private mount factory.
+ *
+ * @see {@link PibblInternalMountedPropAttachment}
+ */
+export declare function pibblInternalCreatePropAttachment<T extends object>(property: 'physics', publicValue: T, mount: () => PibblInternalMountedPropAttachment): T;
+/** @internal Layer cache key for otherwise field-identical enhanced elements. */
+export declare function haveSameElementEnhancers(left: PibblElement<any>, right: PibblElement<any>): boolean;
+/** @internal Reads identity-transparent policy descriptors for snapshots. */
+export declare function getElementEnhancerDescriptors(element: PibblElement<any>): readonly PibblElementEnhancerDescriptor[];
+/** @internal */
+export declare function hasElementEnhancer(element: PibblElement<any>, key: symbol): boolean;
+/** @internal */
+export declare function reconcileElementEnhancers(component: PibblComponentRefs<any>, instance: PibblInstance, reconcilePrimitiveAttachments?: boolean): void;
+/** @internal Reports whether a primitive has mounted official attachments. */
+export declare function hasElementEnhancers(component: PibblComponentRefs<any>): boolean;
+/** @internal Prepares mounted official attachments against resolved geometry. */
+export declare function prepareElementEnhancers(component: PibblComponentRefs<any>, input: PibblInternalPrimitiveAttachmentInput): Readonly<{
+    readonly presentationTransform2D?: DOMMatrix;
+}> | void;
+/** @internal */
+export declare function enterElementEnhancers(component: PibblComponentRefs<any>): readonly PibblMountedElementEnhancerEntry[];
+/** @internal */
+export declare function exitElementEnhancers(entered: readonly PibblMountedElementEnhancerEntry[], success: boolean): void;
+/** @internal */
+export declare function disposeElementEnhancers(component: PibblComponentRefs<any>): void;
+export {};

package/dist/lib/element-enhancers.js

@@ -0,0 +1,193 @@
+import { runTeardown } from "./teardowns.js";
+import { clonePibblElement } from "./element/create-element.js";
+import {
+  getElementSource,
+  registerElementCloneMetadataHandler
+} from "./element/metadata.js";
+const PHYSICS_PROP_ATTACHMENT_KEY = /* @__PURE__ */ Symbol("physics prop attachment");
+const elementEnhancers = /* @__PURE__ */ new WeakMap();
+const mountedElementEnhancers = /* @__PURE__ */ new WeakMap();
+const propAttachments = /* @__PURE__ */ new WeakMap();
+registerElementCloneMetadataHandler((source, clone) => {
+  const descriptors = elementEnhancers.get(source);
+  if (descriptors) {
+    elementEnhancers.set(clone, Object.freeze([...descriptors]));
+  }
+});
+function appendElementEnhancer(element, descriptor) {
+  const enhanced = clonePibblElement(element);
+  elementEnhancers.set(enhanced, Object.freeze([
+    ...elementEnhancers.get(element) ?? [],
+    descriptor
+  ]));
+  return enhanced;
+}
+function pibblInternalCreatePropAttachment(property, publicValue, mount) {
+  propAttachments.set(publicValue, { property, mount });
+  return publicValue;
+}
+function haveSameElementEnhancers(left, right) {
+  const leftDescriptors = elementEnhancers.get(left) ?? [];
+  const rightDescriptors = elementEnhancers.get(right) ?? [];
+  return leftDescriptors.length === rightDescriptors.length && leftDescriptors.every(
+    (descriptor, index) => descriptor === rightDescriptors[index]
+  );
+}
+function getElementEnhancerDescriptors(element) {
+  return elementEnhancers.get(element) ?? [];
+}
+function hasElementEnhancer(element, key) {
+  return elementEnhancers.get(element)?.some(
+    (descriptor) => descriptor.key === key
+  ) ?? false;
+}
+function reconcileElementEnhancers(component, instance, reconcilePrimitiveAttachments = false) {
+  const privateDescriptors = elementEnhancers.get(component.element) ?? [];
+  const propAttachment = reconcilePrimitiveAttachments ? getPrimitivePropAttachment(component.element) : void 0;
+  const descriptors = propAttachment ? [...privateDescriptors, propAttachment] : privateDescriptors;
+  assertUniqueDescriptorKeys(descriptors);
+  const hasOwnership = mountedElementEnhancers.has(component);
+  const previous = mountedElementEnhancers.get(component) ?? [];
+  const previousByKey = new Map(previous.map((entry) => [entry.key, entry]));
+  const next = [];
+  const acquired = [];
+  try {
+    for (const descriptor of descriptors) {
+      let entry = previousByKey.get(descriptor.key);
+      if (!entry) {
+        entry = {
+          key: descriptor.key,
+          mounted: descriptor.mount({ component, instance })
+        };
+        acquired.push(entry);
+      }
+      entry.mounted.update(descriptor);
+      next.push(entry);
+    }
+  } catch (error) {
+    disposeEntries(acquired);
+    throw error;
+  }
+  const nextKeys = new Set(next.map((entry) => entry.key));
+  const removed = previous.filter((entry) => !nextKeys.has(entry.key));
+  if (hasOwnership || next.length > 0) {
+    mountedElementEnhancers.set(component, next);
+    if (!hasOwnership) {
+      component.teardowns.add(() => disposeElementEnhancers(component));
+    }
+  }
+  disposeEntries(removed);
+}
+function hasElementEnhancers(component) {
+  return (mountedElementEnhancers.get(component) ?? []).some(
+    (entry) => entry.mounted.preparePrimitive !== void 0
+  );
+}
+function prepareElementEnhancers(component, input) {
+  let presentationTransform2D;
+  for (const entry of mountedElementEnhancers.get(component) ?? []) {
+    const prepared = entry.mounted.preparePrimitive?.(input);
+    presentationTransform2D = prepared?.presentationTransform2D ?? presentationTransform2D;
+  }
+  return presentationTransform2D ? { presentationTransform2D } : void 0;
+}
+function enterElementEnhancers(component) {
+  const entered = [];
+  try {
+    for (const entry of mountedElementEnhancers.get(component) ?? []) {
+      entry.mounted.enter();
+      entered.push(entry);
+    }
+  } catch (error) {
+    try {
+      exitElementEnhancers(entered, false);
+    } catch (exitError) {
+      runTeardown(() => {
+        throw exitError;
+      });
+    }
+    throw error;
+  }
+  return entered;
+}
+function exitElementEnhancers(entered, success) {
+  let firstError;
+  for (let index = entered.length - 1; index >= 0; index--) {
+    try {
+      entered[index].mounted.exit(success);
+    } catch (error) {
+      firstError ??= error;
+      success = false;
+    }
+  }
+  if (firstError) throw firstError;
+}
+function disposeElementEnhancers(component) {
+  const entries = mountedElementEnhancers.get(component) ?? [];
+  mountedElementEnhancers.delete(component);
+  disposeEntries(entries);
+}
+function assertUniqueDescriptorKeys(descriptors) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const descriptor of descriptors) {
+    if (keys.has(descriptor.key)) {
+      throw new Error(
+        `Duplicate Pibbl element enhancer "${descriptor.key.description ?? "anonymous"}".`
+      );
+    }
+    keys.add(descriptor.key);
+  }
+}
+function getPrimitivePropAttachment(element) {
+  const value = element.props.physics;
+  if (value === void 0 || value === null) return void 0;
+  const record = isObject(value) ? propAttachments.get(value) : void 0;
+  if (!record || record.property !== "physics") {
+    throw invalidPropAttachmentError(element, "physics");
+  }
+  return {
+    key: PHYSICS_PROP_ATTACHMENT_KEY,
+    value,
+    mount() {
+      const mounted = record.mount();
+      return {
+        update(next) {
+          mounted.update(next.value);
+        },
+        enter: () => mounted.enter(),
+        preparePrimitive: (input) => mounted.preparePrimitive(input),
+        exit: (success) => mounted.exit(success),
+        dispose: () => mounted.dispose()
+      };
+    }
+  };
+}
+function invalidPropAttachmentError(element, property) {
+  const componentName = element.type.name || "Anonymous";
+  const source = getElementSource(element);
+  return new Error(
+    `${componentName} received an unregistered ${property} prop attachment. Use the matching official Pibbl package factory.` + (source ? ` JSX source: ${source.fileName}:${source.lineNumber}:${source.columnNumber}.` : "")
+  );
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function disposeEntries(entries) {
+  for (let index = entries.length - 1; index >= 0; index--) {
+    runTeardown(() => entries[index].mounted.dispose());
+  }
+}
+export {
+  appendElementEnhancer,
+  disposeElementEnhancers,
+  enterElementEnhancers,
+  exitElementEnhancers,
+  getElementEnhancerDescriptors,
+  hasElementEnhancer,
+  hasElementEnhancers,
+  haveSameElementEnhancers,
+  pibblInternalCreatePropAttachment,
+  prepareElementEnhancers,
+  reconcileElementEnhancers
+};
+//# sourceMappingURL=element-enhancers.js.map

package/dist/lib/element-enhancers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/lib/element-enhancers.ts"],
+  "sourcesContent": ["import { runTeardown } from './teardowns.js';\nimport { clonePibblElement } from './element/create-element.js';\nimport {\n  getElementSource,\n  registerElementCloneMetadataHandler,\n  type PibblElementSource,\n} from './element/metadata.js';\nimport type {\n  PibblComponentRefs,\n  PibblElement,\n  PibblInstance,\n} from './types.js';\nimport type { PibblPresentationTransformLineage } from './global-state.js';\n\n/**\n * Resolved primitive inputs and transform lineage supplied to an official attachment integration.\n *\n * @see {@link PibblElementSource}\n * @see {@link PibblInternalMountedPropAttachment}\n */\nexport interface PibblInternalPrimitiveAttachmentInput {\n  /**\n   * Component function owning the primitive attachment. See\n   * {@link PibblInternalPrimitiveAttachmentInput}.\n   */\n  readonly componentType: Function;\n  /** Component name retained for diagnostics. See {@link PibblInternalPrimitiveAttachmentInput}. */\n  readonly componentName: string;\n  /**\n   * Component props supplied to evaluation or measurement. See\n   * {@link PibblInternalPrimitiveAttachmentInput}.\n   */\n  readonly props: Readonly<Record<PropertyKey, unknown>>;\n  /**\n   * Declared presentation and layout properties. See {@link PibblInternalPrimitiveAttachmentInput}.\n   */\n  readonly style: Readonly<Record<PropertyKey, unknown>>;\n  /** Authoring source location retained for diagnostics. See {@link PibblElementSource}. */\n  readonly source: PibblElementSource | undefined;\n  /** World transform at the primitive's parent. See {@link PibblInternalPrimitiveAttachmentInput}. */\n  readonly parentWorldTransform: DOMMatrix;\n  /** Exact Pibbl-owned transform lineage at this primitive's parent. */\n  readonly presentationTransformLineage: PibblPresentationTransformLineage | undefined;\n  /** A direct Canvas transform occurred outside the tracked Pibbl lineage. */\n  readonly hasUntrackedCanvasTransform: boolean;\n}\n\n/**\n * Mount-owned primitive attachment with explicit update and teardown semantics.\n *\n * @see {@link PibblInternalPrimitiveAttachmentInput}\n * @see {@link pibblInternalCreatePropAttachment}\n */\nexport interface PibblInternalMountedPropAttachment {\n  /**\n   * Updates the mounted attachment using the latest resolved primitive inputs. See\n   * {@link PibblInternalMountedPropAttachment}.\n   * @param value - Latest attachment descriptor supplied by the component.\n   */\n  update(value: unknown): void;\n  /**\n   * Enters the attachment's scope before primitive evaluation. See\n   * {@link PibblInternalMountedPropAttachment}.\n   */\n  enter(): void;\n  /**\n   * Prepares the attachment against the primitive's resolved inputs. See\n   * {@link PibblInternalMountedPropAttachment}.\n   * @param input - Primitive props, style, and geometry for attachment preparation. See\n   * {@link PibblInternalPrimitiveAttachmentInput} .\n   * @returns An optional presentation transform for the primitive.\n   */\n  preparePrimitive(input: PibblInternalPrimitiveAttachmentInput): Readonly<{\n    /**\n     * Transform applied to the primitive's presented Canvas geometry. See\n     * {@link PibblInternalMountedPropAttachment}.\n     */\n    readonly presentationTransform2D?: DOMMatrix;\n  }> | void;\n  /**\n   * Restores the surrounding scope after primitive evaluation. See\n   * {@link PibblInternalMountedPropAttachment}.\n   * @param success - Whether the attached component completed successfully.\n   */\n  exit(success: boolean): void;\n  /**\n   * Releases resources owned by this mounted object. See {@link PibblInternalMountedPropAttachment}\n   * .\n   */\n  dispose(): void;\n}\n\nexport interface PibblElementEnhancerDescriptor {\n  readonly key: symbol;\n  mount(context: {\n    readonly component: PibblComponentRefs<any>;\n    readonly instance: PibblInstance;\n  }): PibblMountedElementEnhancer;\n}\n\nexport interface PibblMountedElementEnhancer {\n  update(next: PibblElementEnhancerDescriptor): void;\n  enter(): void;\n  preparePrimitive?(\n    input: PibblInternalPrimitiveAttachmentInput,\n  ): Readonly<{ readonly presentationTransform2D?: DOMMatrix }> | void;\n  exit(success: boolean): void;\n  dispose(): void;\n}\n\ninterface PibblMountedElementEnhancerEntry {\n  readonly key: symbol;\n  readonly mounted: PibblMountedElementEnhancer;\n}\n\ninterface AttachmentFactoryRecord {\n  readonly property: 'physics';\n  readonly mount: () => PibblInternalMountedPropAttachment;\n}\n\ninterface PibblPropAttachmentDescriptor extends PibblElementEnhancerDescriptor {\n  readonly key: typeof PHYSICS_PROP_ATTACHMENT_KEY;\n  readonly value: object;\n}\n\nconst PHYSICS_PROP_ATTACHMENT_KEY = Symbol('physics prop attachment');\n\nconst elementEnhancers = new WeakMap<\n  PibblElement<any>,\n  readonly PibblElementEnhancerDescriptor[]\n>();\nconst mountedElementEnhancers = new WeakMap<\n  PibblComponentRefs<any>,\n  PibblMountedElementEnhancerEntry[]\n>();\nconst propAttachments = new WeakMap<object, AttachmentFactoryRecord>();\n\nregisterElementCloneMetadataHandler((source, clone) => {\n  const descriptors = elementEnhancers.get(source);\n  if (descriptors) {\n    elementEnhancers.set(clone, Object.freeze([...descriptors]));\n  }\n});\n\n/** @internal Adds private metadata without introducing a component boundary. */\nexport function appendElementEnhancer<P>(\n  element: PibblElement<P>,\n  descriptor: PibblElementEnhancerDescriptor,\n): PibblElement<P>;\nexport function appendElementEnhancer(\n  element: PibblElement<any>,\n  descriptor: PibblElementEnhancerDescriptor,\n): PibblElement<any> {\n  const enhanced = clonePibblElement(element);\n  elementEnhancers.set(enhanced, Object.freeze([\n    ...(elementEnhancers.get(element) ?? []),\n    descriptor,\n  ]));\n  return enhanced;\n}\n\n/**\n * Registers one closed official-package attachment without mutating its public value.\n *\n * @param property - Reserved prop name receiving the attachment.\n * @param publicValue - Public descriptor exposed to component authors.\n * @param mount - Factory creating the mounted attachment lifetime. See\n * {@link PibblInternalMountedPropAttachment} .\n * @returns The public descriptor associated with the private mount factory.\n *\n * @see {@link PibblInternalMountedPropAttachment}\n */\nexport function pibblInternalCreatePropAttachment<T extends object>(\n  property: 'physics',\n  publicValue: T,\n  mount: () => PibblInternalMountedPropAttachment,\n): T {\n  propAttachments.set(publicValue, { property, mount });\n  return publicValue;\n}\n\n/** @internal Layer cache key for otherwise field-identical enhanced elements. */\nexport function haveSameElementEnhancers(\n  left: PibblElement<any>,\n  right: PibblElement<any>,\n): boolean {\n  const leftDescriptors = elementEnhancers.get(left) ?? [];\n  const rightDescriptors = elementEnhancers.get(right) ?? [];\n  return leftDescriptors.length === rightDescriptors.length &&\n    leftDescriptors.every((descriptor, index) =>\n      descriptor === rightDescriptors[index]\n    );\n}\n\n/** @internal Reads identity-transparent policy descriptors for snapshots. */\nexport function getElementEnhancerDescriptors(\n  element: PibblElement<any>,\n): readonly PibblElementEnhancerDescriptor[] {\n  return elementEnhancers.get(element) ?? [];\n}\n\n/** @internal */\nexport function hasElementEnhancer(\n  element: PibblElement<any>,\n  key: symbol,\n): boolean {\n  return elementEnhancers.get(element)?.some(descriptor =>\n    descriptor.key === key\n  ) ?? false;\n}\n\n/** @internal */\nexport function reconcileElementEnhancers(\n  component: PibblComponentRefs<any>,\n  instance: PibblInstance,\n  reconcilePrimitiveAttachments = false,\n): void {\n  const privateDescriptors = elementEnhancers.get(component.element) ?? [];\n  const propAttachment = reconcilePrimitiveAttachments ?\n    getPrimitivePropAttachment(component.element) :\n    undefined;\n  const descriptors = propAttachment ?\n    [...privateDescriptors, propAttachment] :\n    privateDescriptors;\n  assertUniqueDescriptorKeys(descriptors);\n\n  const hasOwnership = mountedElementEnhancers.has(component);\n  const previous = mountedElementEnhancers.get(component) ?? [];\n  const previousByKey = new Map(previous.map(entry => [entry.key, entry]));\n  const next: PibblMountedElementEnhancerEntry[] = [];\n  const acquired: PibblMountedElementEnhancerEntry[] = [];\n\n  try {\n    for (const descriptor of descriptors) {\n      let entry = previousByKey.get(descriptor.key);\n      if (!entry) {\n        entry = {\n          key: descriptor.key,\n          mounted: descriptor.mount({ component, instance }),\n        };\n        acquired.push(entry);\n      }\n      entry.mounted.update(descriptor);\n      next.push(entry);\n    }\n  } catch (error) {\n    disposeEntries(acquired);\n    throw error;\n  }\n\n  const nextKeys = new Set(next.map(entry => entry.key));\n  const removed = previous.filter(entry => !nextKeys.has(entry.key));\n  if (hasOwnership || next.length > 0) {\n    mountedElementEnhancers.set(component, next);\n    if (!hasOwnership) {\n      component.teardowns.add(() => disposeElementEnhancers(component));\n    }\n  }\n  disposeEntries(removed);\n}\n\n/** @internal Reports whether a primitive has mounted official attachments. */\nexport function hasElementEnhancers(component: PibblComponentRefs<any>): boolean {\n  return (mountedElementEnhancers.get(component) ?? []).some(\n    entry => entry.mounted.preparePrimitive !== undefined,\n  );\n}\n\n/** @internal Prepares mounted official attachments against resolved geometry. */\nexport function prepareElementEnhancers(\n  component: PibblComponentRefs<any>,\n  input: PibblInternalPrimitiveAttachmentInput,\n): Readonly<{ readonly presentationTransform2D?: DOMMatrix }> | void {\n  let presentationTransform2D: DOMMatrix | undefined;\n  for (const entry of mountedElementEnhancers.get(component) ?? []) {\n    const prepared = entry.mounted.preparePrimitive?.(input);\n    presentationTransform2D =\n      prepared?.presentationTransform2D ?? presentationTransform2D;\n  }\n  return presentationTransform2D ? { presentationTransform2D } : undefined;\n}\n\n/** @internal */\nexport function enterElementEnhancers(\n  component: PibblComponentRefs<any>,\n): readonly PibblMountedElementEnhancerEntry[] {\n  const entered: PibblMountedElementEnhancerEntry[] = [];\n  try {\n    for (const entry of mountedElementEnhancers.get(component) ?? []) {\n      entry.mounted.enter();\n      entered.push(entry);\n    }\n  } catch (error) {\n    try {\n      exitElementEnhancers(entered, false);\n    } catch (exitError) {\n      runTeardown(() => { throw exitError; });\n    }\n    throw error;\n  }\n  return entered;\n}\n\n/** @internal */\nexport function exitElementEnhancers(\n  entered: readonly PibblMountedElementEnhancerEntry[],\n  success: boolean,\n): void {\n  let firstError: unknown;\n  for (let index = entered.length - 1; index >= 0; index--) {\n    try {\n      entered[index].mounted.exit(success);\n    } catch (error) {\n      firstError ??= error;\n      success = false;\n    }\n  }\n  if (firstError) throw firstError;\n}\n\n/** @internal */\nexport function disposeElementEnhancers(component: PibblComponentRefs<any>): void {\n  const entries = mountedElementEnhancers.get(component) ?? [];\n  mountedElementEnhancers.delete(component);\n  disposeEntries(entries);\n}\n\nfunction assertUniqueDescriptorKeys(\n  descriptors: readonly PibblElementEnhancerDescriptor[],\n): void {\n  const keys = new Set<symbol>();\n  for (const descriptor of descriptors) {\n    if (keys.has(descriptor.key)) {\n      throw new Error(\n        `Duplicate Pibbl element enhancer \"${descriptor.key.description ?? 'anonymous'}\".`,\n      );\n    }\n    keys.add(descriptor.key);\n  }\n}\n\nfunction getPrimitivePropAttachment(\n  element: PibblElement<any>,\n): PibblPropAttachmentDescriptor | undefined {\n  const value = (element.props as Readonly<Record<PropertyKey, unknown>>).physics;\n  if (value === undefined || value === null) return undefined;\n  const record = isObject(value) ? propAttachments.get(value) : undefined;\n  if (!record || record.property !== 'physics') {\n    throw invalidPropAttachmentError(element, 'physics');\n  }\n  return {\n    key: PHYSICS_PROP_ATTACHMENT_KEY,\n    value,\n    mount() {\n      const mounted = record.mount();\n      return {\n        update(next) {\n          mounted.update((next as PibblPropAttachmentDescriptor).value);\n        },\n        enter: () => mounted.enter(),\n        preparePrimitive: input => mounted.preparePrimitive(input),\n        exit: success => mounted.exit(success),\n        dispose: () => mounted.dispose(),\n      };\n    },\n  };\n}\n\nfunction invalidPropAttachmentError(\n  element: PibblElement<any>,\n  property: 'physics',\n): Error {\n  const componentName = element.type.name || 'Anonymous';\n  const source = getElementSource(element);\n  return new Error(\n    `${componentName} received an unregistered ${property} prop attachment.` +\n      ' Use the matching official Pibbl package factory.' +\n      (source ?\n        ` JSX source: ${source.fileName}:${source.lineNumber}:${source.columnNumber}.` :\n        ''),\n  );\n}\n\nfunction isObject(value: unknown): value is object {\n  return (typeof value === 'object' && value !== null) ||\n    typeof value === 'function';\n}\n\nfunction disposeEntries(entries: readonly PibblMountedElementEnhancerEntry[]): void {\n  for (let index = entries.length - 1; index >= 0; index--) {\n    runTeardown(() => entries[index].mounted.dispose());\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/events/adapters/clipboard.d.ts

@@ -0,0 +1,9 @@
+import type { PibblEventType } from '../types.js';
+export declare const PIBBL_NATIVE_CLIPBOARD_EVENT_TYPES: readonly ["copy", "cut", "paste"];
+export type PibblNativeClipboardEventType = (typeof PIBBL_NATIVE_CLIPBOARD_EVENT_TYPES)[number];
+export interface PibblAdaptedClipboardEvent {
+    readonly type: PibblNativeClipboardEventType;
+    readonly originalEvent: ClipboardEvent;
+}
+export declare function isNativeClipboardEventType(type: PibblEventType): type is PibblNativeClipboardEventType;
+export declare function adaptClipboardEvent(type: PibblNativeClipboardEventType, event: Event): PibblAdaptedClipboardEvent | undefined;

package/dist/lib/events/adapters/clipboard.js

@@ -0,0 +1,23 @@
+const PIBBL_NATIVE_CLIPBOARD_EVENT_TYPES = Object.freeze([
+  "copy",
+  "cut",
+  "paste"
+]);
+const nativeClipboardEventTypes = new Set(
+  PIBBL_NATIVE_CLIPBOARD_EVENT_TYPES
+);
+function isNativeClipboardEventType(type) {
+  return nativeClipboardEventTypes.has(type);
+}
+function adaptClipboardEvent(type, event) {
+  if (typeof ClipboardEvent === "undefined" || !(event instanceof ClipboardEvent)) {
+    return void 0;
+  }
+  return { type, originalEvent: event };
+}
+export {
+  PIBBL_NATIVE_CLIPBOARD_EVENT_TYPES,
+  adaptClipboardEvent,
+  isNativeClipboardEventType
+};
+//# sourceMappingURL=clipboard.js.map

package/dist/lib/events/adapters/clipboard.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/lib/events/adapters/clipboard.ts"],
+  "sourcesContent": ["import type { PibblEventType } from '../types.js';\n\nexport const PIBBL_NATIVE_CLIPBOARD_EVENT_TYPES = Object.freeze([\n  'copy',\n  'cut',\n  'paste',\n] as const satisfies readonly PibblEventType[]);\n\nexport type PibblNativeClipboardEventType =\n  (typeof PIBBL_NATIVE_CLIPBOARD_EVENT_TYPES)[number];\n\nconst nativeClipboardEventTypes = new Set<PibblEventType>(\n  PIBBL_NATIVE_CLIPBOARD_EVENT_TYPES,\n);\n\nexport interface PibblAdaptedClipboardEvent {\n  readonly type: PibblNativeClipboardEventType;\n  readonly originalEvent: ClipboardEvent;\n}\n\nexport function isNativeClipboardEventType(\n  type: PibblEventType,\n): type is PibblNativeClipboardEventType {\n  return nativeClipboardEventTypes.has(type);\n}\n\nexport function adaptClipboardEvent(\n  type: PibblNativeClipboardEventType,\n  event: Event,\n): PibblAdaptedClipboardEvent | undefined {\n  if (\n    typeof ClipboardEvent === 'undefined' ||\n    !(event instanceof ClipboardEvent)\n  ) {\n    return undefined;\n  }\n  return { type, originalEvent: event };\n}\n"],
+  "mappings": "AAEO,MAAM,qCAAqC,OAAO,OAAO;AAAA,EAC9D;AAAA,EACA;AAAA,EACA;AACF,CAA8C;AAK9C,MAAM,4BAA4B,IAAI;AAAA,EACpC;AACF;AAOO,SAAS,2BACd,MACuC;AACvC,SAAO,0BAA0B,IAAI,IAAI;AAC3C;AAEO,SAAS,oBACd,MACA,OACwC;AACxC,MACE,OAAO,mBAAmB,eAC1B,EAAE,iBAAiB,iBACnB;AACA,WAAO;AAAA,EACT;AACA,SAAO,EAAE,MAAM,eAAe,MAAM;AACtC;",
+  "names": []
+}

package/dist/lib/events/adapters/drag.d.ts

@@ -0,0 +1,12 @@
+import type { PibblInstance } from '../../types.js';
+import type { PibblEventType } from '../types.js';
+export declare const PIBBL_NATIVE_DRAG_EVENT_TYPES: readonly ["dragstart", "drag", "dragend", "dragenter", "dragleave", "dragover", "drop"];
+export type PibblNativeDragEventType = (typeof PIBBL_NATIVE_DRAG_EVENT_TYPES)[number];
+export interface PibblAdaptedDragEvent {
+    readonly type: PibblNativeDragEventType;
+    readonly originalEvent: DragEvent;
+    readonly x: number;
+    readonly y: number;
+}
+export declare function isNativeDragEventType(type: PibblEventType): type is PibblNativeDragEventType;
+export declare function adaptDragEvent(root: PibblInstance, type: PibblNativeDragEventType, event: Event): PibblAdaptedDragEvent | undefined;