@weasel-js/core 1.10.0 → 1.11.0

package/dist/canvas/slopsDebugLayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"slopsDebugLayer.js","names":["SLOP_FILL","SLOP_STROKE","createSlopsDebugLayer","chrome","chromeStateFrom","data","isVisible","isVisibleFrom","toScreen","x","view","y","out","a","opts","region","q","pointRegionScreenQuad","transformOf","PATH_M","PATH_L","PATH_Z"],"sources":["../../src/canvas/slopsDebugLayer.ts"],"sourcesContent":["/**\n * Screen-space debug overlay rendering the kit's hit-test \"slops\" — the\n * forgiveness regions around each point affordance (corner resize handles,\n * the rotate badge, anchor / control-handle markers). Off by default; gated\n * by SceneCanvas's `debug.slops` prop.\n *\n * It walks the same affordances the hit-test does, and draws each point\n * region's square from the same frame the hit-test reads, so a halo shows\n * exactly the pixels that grab.\n */\n\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { Affordance } from 'affordances/types';\nimport { pointRegionScreenQuad, transformOf } from 'affordances/hitAffordanceRegions';\nimport { PATH_L, PATH_M, PATH_Z } from '@weasel-js/geom';\nimport { chromeStateFrom, isVisibleFrom } from './drawEnvelope';\n\nexport interface CreateSlopsDebugLayerOptions {\n  /** The affordances the canvas hit-tests — `chromeAffordances`, the same\n   *  list handed to `buildAffordanceAt`. */\n  getAffordances: () => readonly Affordance[];\n}\n\nconst SLOP_FILL = 'rgba(255, 80, 140, 0.18)';\nconst SLOP_STROKE = 'rgba(255, 80, 140, 0.55)';\n\nexport function createSlopsDebugLayer(\n  opts: CreateSlopsDebugLayerOptions,\n): RenderLayer<unknown> {\n  return {\n    id: 'slops-debug',\n    label: 'Slops (debug)',\n    space: 'screen',\n    draw: (data, view) => {\n      // Selection, bounds and visibility come off the envelope: the halos\n      // have to sit on the chrome the drawing view actually painted.\n      const chrome = chromeStateFrom(data);\n      if (!chrome) return [];\n      const isVisible = isVisibleFrom(data);\n      const toScreen = (x: number, y: number): [number, number] =>\n        [(x - view.x) * view.scale.x, (y - view.y) * view.scale.y];\n      const out: DrawCommand[] = [];\n      for (const a of opts.getAffordances()) {\n        if (isVisible && !isVisible(a.id)) continue;\n        for (const region of a.regions(chrome)) {\n          if (region.shape.kind !== 'point') continue;\n          const q = pointRegionScreenQuad(\n            region.shape, transformOf(chrome, region.targetId), view, toScreen,\n          );\n          out.push({\n            kind: 'path',\n            path: {\n              kind: 'polygon',\n              commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n              coords: new Float32Array([q[0].x, q[0].y, q[1].x, q[1].y, q[2].x, q[2].y, q[3].x, q[3].y]),\n              fillRule: 'nonzero',\n            },\n            fill: { paint: { kind: 'solid', color: SLOP_FILL } },\n            stroke: { paint: { kind: 'solid', color: SLOP_STROKE }, width: 1 },\n          });\n        }\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";;;;AAwBA,IAAMA,IAAY,4BACZC,IAAc;AAEpB,SAAgBC,EACd,GACsB;CACtB,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,OAAO,GAAM,MAAS;GAGpB,IAAMC,IAASC,EAAgBC,CAAI;GACnC,IAAI,CAACF,GAAQ,OAAO,CAAC;GACrB,IAAMG,IAAYC,EAAcF,CAAI,GAC9BG,KAAY,GAAW,MAC3B,EAAEC,IAAIC,EAAK,KAAKA,EAAK,MAAM,IAAIC,IAAID,EAAK,KAAKA,EAAK,MAAM,CAAC,GACrDE,IAAqB,CAAC;GAC5B,KAAK,IAAMC,KAAKC,EAAK,eAAe,GAClC,IAAI,MAAcR,EAAUO,EAAE,EAAE,GAChC,KAAK,IAAME,KAAUF,EAAE,QAAQV,CAAM,GAAG;IACtC,IAAIY,EAAO,MAAM,SAAS,SAAS;IACnC,IAAMC,IAAIC,EACRF,EAAO,OAAOG,EAAYf,GAAQY,EAAO,QAAQ,GAAGL,GAAMF,CAC5D;IACA,EAAI,KAAK;KACP,MAAM;KACN,MAAM;MACJ,MAAM;MACN,UAAU,IAAI,WAAW;OAACW;OAAQC;OAAQA;OAAQA;OAAQC;MAAM,CAAC;MACjE,QAAQ,IAAI,aAAa;OAACL,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;MAAC,CAAC;MACzF,UAAU;KACZ;KACA,MAAM,EAAE,OAAO;MAAE,MAAM;MAAS,OAAOhB;KAAU,EAAE;KACnD,QAAQ;MAAE,OAAO;OAAE,MAAM;OAAS,OAAOC;MAAY;MAAG,OAAO;KAAE;IACnE,CAAC;GACH;GAEF,OAAOW;EACT;CACF;AACF"}
+{"version":3,"file":"slopsDebugLayer.js","names":[],"sources":["../../src/canvas/slopsDebugLayer.ts"],"sourcesContent":["/**\n * Screen-space debug overlay rendering the kit's hit-test \"slops\" — the\n * forgiveness regions around each point affordance (corner resize handles,\n * the rotate badge, anchor / control-handle markers). Off by default; gated\n * by SceneCanvas's `debug.slops` prop.\n *\n * It walks the same affordances the hit-test does, and draws each point\n * region's square from the same frame the hit-test reads, so a halo shows\n * exactly the pixels that grab.\n */\n\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { Affordance } from 'affordances/types';\nimport { pointRegionLive, pointRegionScreenQuad, transformOf } from 'affordances/hitAffordanceRegions';\nimport { PATH_L, PATH_M, PATH_Z } from '@weasel-js/geom';\nimport { chromeStateFrom, isVisibleFrom } from './drawEnvelope';\n\nexport interface CreateSlopsDebugLayerOptions {\n  /** The affordances the canvas hit-tests — `chromeAffordances`, the same\n   *  list handed to `buildAffordanceAt`. */\n  getAffordances: () => readonly Affordance[];\n}\n\nconst SLOP_FILL = 'rgba(255, 80, 140, 0.18)';\nconst SLOP_STROKE = 'rgba(255, 80, 140, 0.55)';\n\nexport function createSlopsDebugLayer(\n  opts: CreateSlopsDebugLayerOptions,\n): RenderLayer<unknown> {\n  return {\n    id: 'slops-debug',\n    label: 'Slops (debug)',\n    space: 'screen',\n    draw: (data, view) => {\n      // Selection, bounds and visibility come off the envelope: the halos\n      // have to sit on the chrome the drawing view actually painted.\n      const chrome = chromeStateFrom(data);\n      if (!chrome) return [];\n      const isVisible = isVisibleFrom(data);\n      const toScreen = (x: number, y: number): [number, number] =>\n        [(x - view.x) * view.scale.x, (y - view.y) * view.scale.y];\n      const out: DrawCommand[] = [];\n      for (const a of opts.getAffordances()) {\n        if (isVisible && !isVisible(a.id)) continue;\n        for (const region of a.regions(chrome)) {\n          if (region.shape.kind !== 'point') continue;\n          const xf = transformOf(chrome, region.targetId);\n          if (!pointRegionLive(region.shape, xf, view)) continue;\n          const q = pointRegionScreenQuad(region.shape, xf, view, toScreen);\n          out.push({\n            kind: 'path',\n            path: {\n              kind: 'polygon',\n              commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n              coords: new Float32Array([q[0].x, q[0].y, q[1].x, q[1].y, q[2].x, q[2].y, q[3].x, q[3].y]),\n              fillRule: 'nonzero',\n            },\n            fill: { paint: { kind: 'solid', color: SLOP_FILL } },\n            stroke: { paint: { kind: 'solid', color: SLOP_STROKE }, width: 1 },\n          });\n        }\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";;;;;AAwBA,IAAM,YAAY;AAClB,IAAM,cAAc;AAEpB,SAAgB,sBACd,MACsB;CACtB,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,OAAO,MAAM,SAAS;GAGpB,MAAM,SAAS,gBAAgB,IAAI;GACnC,IAAI,CAAC,QAAQ,OAAO,CAAC;GACrB,MAAM,YAAY,cAAc,IAAI;GACpC,MAAM,YAAY,GAAW,MAC3B,EAAE,IAAI,KAAK,KAAK,KAAK,MAAM,IAAI,IAAI,KAAK,KAAK,KAAK,MAAM,CAAC;GAC3D,MAAM,MAAqB,CAAC;GAC5B,KAAK,MAAM,KAAK,KAAK,eAAe,GAAG;IACrC,IAAI,aAAa,CAAC,UAAU,EAAE,EAAE,GAAG;IACnC,KAAK,MAAM,UAAU,EAAE,QAAQ,MAAM,GAAG;KACtC,IAAI,OAAO,MAAM,SAAS,SAAS;KACnC,MAAM,KAAK,YAAY,QAAQ,OAAO,QAAQ;KAC9C,IAAI,CAAC,gBAAgB,OAAO,OAAO,IAAI,IAAI,GAAG;KAC9C,MAAM,IAAI,sBAAsB,OAAO,OAAO,IAAI,MAAM,QAAQ;KAChE,IAAI,KAAK;MACP,MAAM;MACN,MAAM;OACJ,MAAM;OACN,UAAU,IAAI,WAAW;QAAC;QAAQ;QAAQ;QAAQ;QAAQ;OAAM,CAAC;OACjE,QAAQ,IAAI,aAAa;QAAC,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;QAAG,EAAE,EAAE,CAAC;OAAC,CAAC;OACzF,UAAU;MACZ;MACA,MAAM,EAAE,OAAO;OAAE,MAAM;OAAS,OAAO;MAAU,EAAE;MACnD,QAAQ;OAAE,OAAO;QAAE,MAAM;QAAS,OAAO;OAAY;OAAG,OAAO;MAAE;KACnE,CAAC;IACH;GACF;GACA,OAAO;EACT;CACF;AACF"}

package/dist/canvas/surfaceContribution.js

@@ -1,15 +1,27 @@
-import { mergeContributions as e } from "@weasel-js/routing";
+import { mergeContributions } from "@weasel-js/routing";
+
 //#region src/canvas/surfaceContribution.ts
-function t(...t) {
-	let n = e(...t), r = /* @__PURE__ */ new Map();
-	for (let e of n) for (let t of e.views ?? []) {
-		let n = r.get(t.id);
-		if (n !== void 0) throw Error(`mergeContributions: view "${t.id}" is added by both "${n}" and "${e.id}". View ids are unique per surface; rename one.`);
-		r.set(t.id, e.id);
+/**
+* The canvas's unit of extension: a routing `Contribution` plus the roles only
+* a surface can install — views on it, and whatever else needs the mounted
+* canvas.
+*/
+/**
+* Concatenate contribution bundles into one registry, preserving order. Throws
+* on a duplicate entry id, dep name or view id — two features answering for
+* the same name is a bug in whichever was added second.
+*/
+function mergeContributions$1(...bundles) {
+	const out = mergeContributions(...bundles);
+	const viewOwner = /* @__PURE__ */ new Map();
+	for (const entry of out) for (const view of entry.views ?? []) {
+		const owner = viewOwner.get(view.id);
+		if (owner !== void 0) throw new Error(`mergeContributions: view "${view.id}" is added by both "${owner}" and "${entry.id}". View ids are unique per surface; rename one.`);
+		viewOwner.set(view.id, entry.id);
 	}
-	return n;
+	return out;
 }
-//#endregion
-export { t as mergeContributions };
 
+//#endregion
+export { mergeContributions$1 as mergeContributions };
 //# sourceMappingURL=surfaceContribution.js.map

package/dist/canvas/surfaceContribution.js.map

@@ -1 +1 @@
-{"version":3,"file":"surfaceContribution.js","names":["mergeContributions","mergeRoutingContributions","mergeContributions$1","bundles","out","mergeContributions","viewOwner","entry","view","owner"],"sources":["../../src/canvas/surfaceContribution.ts"],"sourcesContent":["/**\n * The canvas's unit of extension: a routing `Contribution` plus the roles only\n * a surface can install — views on it, and whatever else needs the mounted\n * canvas.\n */\nimport { mergeContributions as mergeRoutingContributions } from '@weasel-js/routing';\nimport type { DepName, DepSchema } from 'interactions/actions/depSchema';\nimport type { Contribution } from '../tools/overlayBinding';\nimport type { CanvasExtensionApi } from './canvasExtension';\nimport type { CanvasViewProps } from './CanvasView';\nimport type { View } from '../core/viewport/view';\nimport type { KitRequirements } from './kitRequirements';\n\n/** Reads the surface's deps from inside `SurfaceContribution.attach`. */\nexport interface ContributionDepReader {\n  get<K extends DepName>(name: K): DepSchema[K] | undefined;\n}\n\n/** What {@link SurfaceContribution.beforePaint} and `afterPaint` are handed. */\nexport interface ContributionFrameCtx {\n  /** The frame's timestamp, on `performance.now()`'s clock. Both phases of one\n   *  frame see the same value. */\n  readonly time: number;\n  /** The surface camera this frame paints with. */\n  readonly view: View;\n  /** Ask for another frame. A hook animating something calls this every frame\n   *  it still has work for, and stops calling it to let the loop go idle. */\n  requestFrame(): void;\n  /** The surface's deps, as `attach` reads them. */\n  readonly deps: ContributionDepReader;\n}\n\n/**\n * A feature a surface installs in one step. Every role is optional: `bindings`,\n * `actions`, `deps`, `overlay` and `presentation` from `Contribution`, plus\n * the ones below. Installing it installs every role it declares, and removing\n * it removes them.\n */\nexport interface SurfaceContribution extends Contribution {\n  /** Views this entry adds to the surface, as `<SceneCanvas views>` takes. */\n  views?: readonly CanvasViewProps[];\n  /**\n   * Runs once the surface mounts; returns its teardown. For what the roles\n   * above cannot say — a registered (hit-testable) layer, a subscription.\n   *\n   * Keyed by the function's identity, so a contribution built once (in a\n   * `useMemo`, or at module scope) attaches once however often the host\n   * re-renders.\n   */\n  attach?: (api: CanvasExtensionApi, deps: ContributionDepReader) => () => void;\n  /**\n   * Runs on every frame the surface paints, before the paint — for state the\n   * entry's layers read, advanced once per frame. Hooks run in the order the\n   * surface lists its entries (registered tools, then `ambient` in array\n   * order), and one that throws is reported and skipped without stopping the\n   * frame.\n   */\n  beforePaint?: (ctx: ContributionFrameCtx) => void;\n  /** Runs after a frame's pixels have landed, in the same order as\n   *  {@link beforePaint}. A frame that painted nothing runs no `afterPaint`. */\n  afterPaint?: (ctx: ContributionFrameCtx) => void;\n  /**\n   * The kit versions this entry was written against, as semver ranges:\n   * `{ core: '^1.7' }`. A mismatch warns in development, or throws where the\n   * surface is set to `versionCheck=\"strict\"`.\n   */\n  requires?: KitRequirements;\n}\n\n/**\n * Concatenate contribution bundles into one registry, preserving order. Throws\n * on a duplicate entry id, dep name or view id — two features answering for\n * the same name is a bug in whichever was added second.\n */\nexport function mergeContributions<T extends SurfaceContribution>(\n  ...bundles: readonly (readonly T[])[]\n): T[] {\n  const out = mergeRoutingContributions<T>(...bundles);\n  const viewOwner = new Map<string, string>();\n  for (const entry of out) {\n    for (const view of entry.views ?? []) {\n      const owner = viewOwner.get(view.id);\n      if (owner !== undefined) {\n        throw new Error(\n          `mergeContributions: view \"${view.id}\" is added by both \"${owner}\" and \"${entry.id}\". `\n          + `View ids are unique per surface; rename one.`,\n        );\n      }\n      viewOwner.set(view.id, entry.id);\n    }\n  }\n  return out;\n}\n"],"mappings":";;AA0EA,SAAgBA,EACd,GAAGG,GACE;CACL,IAAMC,IAAMH,EAA6B,GAAGE,CAAO,GAC7CG,oBAAY,IAAI,IAAoB;CAC1C,KAAK,IAAMC,KAASH,GAClB,KAAK,IAAMI,KAAQD,EAAM,SAAS,CAAC,GAAG;EACpC,IAAME,IAAQH,EAAU,IAAIE,EAAK,EAAE;EACnC,IAAIC,MAAU,KAAA,GACZ,MAAU,MACR,6BAA6BD,EAAK,GAAG,sBAAsBC,EAAM,SAASF,EAAM,GAAG,gDAErF;EAEF,EAAU,IAAIC,EAAK,IAAID,EAAM,EAAE;CACjC;CAEF,OAAOH;AACT"}
+{"version":3,"file":"surfaceContribution.js","names":["mergeContributions","mergeRoutingContributions"],"sources":["../../src/canvas/surfaceContribution.ts"],"sourcesContent":["/**\n * The canvas's unit of extension: a routing `Contribution` plus the roles only\n * a surface can install — views on it, and whatever else needs the mounted\n * canvas.\n */\nimport { mergeContributions as mergeRoutingContributions } from '@weasel-js/routing';\nimport type { DepName, DepSchema } from 'interactions/actions/depSchema';\nimport type { Contribution } from '../tools/overlayBinding';\nimport type { CanvasExtensionApi } from './canvasExtension';\nimport type { CanvasViewProps } from './CanvasView';\nimport type { View } from '../core/viewport/view';\nimport type { KitRequirements } from './kitRequirements';\n\n/** Reads the surface's deps from inside `SurfaceContribution.attach`. */\nexport interface ContributionDepReader {\n  get<K extends DepName>(name: K): DepSchema[K] | undefined;\n}\n\n/** What {@link SurfaceContribution.beforePaint} and `afterPaint` are handed. */\nexport interface ContributionFrameCtx {\n  /** The frame's timestamp, on `performance.now()`'s clock. Both phases of one\n   *  frame see the same value. */\n  readonly time: number;\n  /** The surface camera this frame paints with. */\n  readonly view: View;\n  /** Ask for another frame. A hook animating something calls this every frame\n   *  it still has work for, and stops calling it to let the loop go idle. */\n  requestFrame(): void;\n  /** The surface's deps, as `attach` reads them. */\n  readonly deps: ContributionDepReader;\n}\n\n/**\n * A feature a surface installs in one step. Every role is optional: `bindings`,\n * `actions`, `deps`, `overlay` and `presentation` from `Contribution`, plus\n * the ones below. Installing it installs every role it declares, and removing\n * it removes them.\n */\nexport interface SurfaceContribution extends Contribution {\n  /** Views this entry adds to the surface, as `<SceneCanvas views>` takes. */\n  views?: readonly CanvasViewProps[];\n  /**\n   * Runs once the surface mounts; returns its teardown. For what the roles\n   * above cannot say — a registered (hit-testable) layer, a subscription.\n   *\n   * Keyed by the function's identity, so a contribution built once (in a\n   * `useMemo`, or at module scope) attaches once however often the host\n   * re-renders.\n   */\n  attach?: (api: CanvasExtensionApi, deps: ContributionDepReader) => () => void;\n  /**\n   * Runs on every frame the surface paints, before the paint — for state the\n   * entry's layers read, advanced once per frame. Hooks run in the order the\n   * surface lists its entries (registered tools, then `ambient` in array\n   * order), and one that throws is reported and skipped without stopping the\n   * frame.\n   */\n  beforePaint?: (ctx: ContributionFrameCtx) => void;\n  /** Runs after a frame's pixels have landed, in the same order as\n   *  {@link beforePaint}. A frame that painted nothing runs no `afterPaint`. */\n  afterPaint?: (ctx: ContributionFrameCtx) => void;\n  /**\n   * The kit versions this entry was written against, as semver ranges:\n   * `{ core: '^1.7' }`. A mismatch warns in development, or throws where the\n   * surface is set to `versionCheck=\"strict\"`.\n   */\n  requires?: KitRequirements;\n}\n\n/**\n * Concatenate contribution bundles into one registry, preserving order. Throws\n * on a duplicate entry id, dep name or view id — two features answering for\n * the same name is a bug in whichever was added second.\n */\nexport function mergeContributions<T extends SurfaceContribution>(\n  ...bundles: readonly (readonly T[])[]\n): T[] {\n  const out = mergeRoutingContributions<T>(...bundles);\n  const viewOwner = new Map<string, string>();\n  for (const entry of out) {\n    for (const view of entry.views ?? []) {\n      const owner = viewOwner.get(view.id);\n      if (owner !== undefined) {\n        throw new Error(\n          `mergeContributions: view \"${view.id}\" is added by both \"${owner}\" and \"${entry.id}\". `\n          + `View ids are unique per surface; rename one.`,\n        );\n      }\n      viewOwner.set(view.id, entry.id);\n    }\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;AA0EA,SAAgBA,qBACd,GAAG,SACE;CACL,MAAM,MAAMC,mBAA6B,GAAG,OAAO;CACnD,MAAM,4BAAY,IAAI,IAAoB;CAC1C,KAAK,MAAM,SAAS,KAClB,KAAK,MAAM,QAAQ,MAAM,SAAS,CAAC,GAAG;EACpC,MAAM,QAAQ,UAAU,IAAI,KAAK,EAAE;EACnC,IAAI,UAAU,QACZ,MAAM,IAAI,MACR,6BAA6B,KAAK,GAAG,sBAAsB,MAAM,SAAS,MAAM,GAAG,gDAErF;EAEF,UAAU,IAAI,KAAK,IAAI,MAAM,EAAE;CACjC;CAEF,OAAO;AACT"}

package/dist/canvas/useCanvasElements.js

@@ -0,0 +1,31 @@
+import { useCallback, useInsertionEffect, useRef } from "react";
+import { useLatest } from "@weasel-js/react";
+
+//#region src/canvas/useCanvasElements.ts
+function useCanvasElements(paintInto, inputElement) {
+	const canvasRef = useRef(null);
+	const ownCanvasRef = useRef(null);
+	const setOwnCanvas = useCallback((el) => {
+		ownCanvasRef.current = el;
+		canvasRef.current = el;
+	}, []);
+	const detached = !!paintInto;
+	useInsertionEffect(() => {
+		if (detached) canvasRef.current = inputElement ?? null;
+	});
+	return {
+		canvasRef,
+		ownCanvasRef,
+		setOwnCanvas,
+		detached,
+		paintTargetRef: useLatest(detached ? paintInto.canvas ?? null : null),
+		paintRectRef: useLatest(detached ? {
+			x: paintInto.x,
+			y: paintInto.y
+		} : null)
+	};
+}
+
+//#endregion
+export { useCanvasElements };
+//# sourceMappingURL=useCanvasElements.js.map

package/dist/canvas/useCanvasElements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasElements.js","names":[],"sources":["../../src/canvas/useCanvasElements.ts"],"sourcesContent":["import { useCallback, useInsertionEffect, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { CanvasProps } from './canvasProps';\n\n/** The elements a canvas reads input from and paints into. */\nexport interface CanvasElements {\n  /**\n   * The element input comes from and every client→world conversion measures: the `<canvas>`\n   * this component renders, or under `paintInto` the caller's `inputElement`.\n   */\n  canvasRef: { current: HTMLElement | null };\n  /** The `<canvas>` this component rendered, if it rendered one. */\n  ownCanvasRef: { current: HTMLCanvasElement | null };\n  /** React's ref callback for the rendered `<canvas>`. */\n  setOwnCanvas: (el: HTMLCanvasElement | null) => void;\n  detached: boolean;\n  /** Where pixels go when detached; null otherwise. */\n  paintTargetRef: { readonly current: HTMLCanvasElement | null };\n  /** The detached tile's origin on its target; null otherwise. */\n  paintRectRef: { readonly current: { x: number; y: number } | null };\n}\n\nexport function useCanvasElements(\n  paintInto: CanvasProps<unknown>['paintInto'],\n  inputElement: HTMLElement | null | undefined,\n): CanvasElements {\n  const canvasRef = useRef<HTMLElement | null>(null);\n  const ownCanvasRef = useRef<HTMLCanvasElement | null>(null);\n  // Stable, so a commit does not detach the element: an inline ref is nulled\n  // until the layout phase reaches it, and a sync paint asked for before that\n  // finds no canvas.\n  const setOwnCanvas = useCallback((el: HTMLCanvasElement | null) => {\n    ownCanvasRef.current = el;\n    canvasRef.current = el;\n  }, []);\n  const detached = !!paintInto;\n  // The detached input element reaches `canvasRef` at commit; the own canvas\n  // arrives through `setOwnCanvas`.\n  useInsertionEffect(() => {\n    if (detached) canvasRef.current = inputElement ?? null;\n  });\n  const paintTargetRef = useLatest(detached ? (paintInto.canvas ?? null) : null);\n  const paintRectRef = useLatest(detached ? { x: paintInto.x, y: paintInto.y } : null);\n  return { canvasRef, ownCanvasRef, setOwnCanvas, detached, paintTargetRef, paintRectRef };\n}\n"],"mappings":";;;;AAsBA,SAAgB,kBACd,WACA,cACgB;CAChB,MAAM,YAAY,OAA2B,IAAI;CACjD,MAAM,eAAe,OAAiC,IAAI;CAI1D,MAAM,eAAe,aAAa,OAAiC;EACjE,aAAa,UAAU;EACvB,UAAU,UAAU;CACtB,GAAG,CAAC,CAAC;CACL,MAAM,WAAW,CAAC,CAAC;CAGnB,yBAAyB;EACvB,IAAI,UAAU,UAAU,UAAU,gBAAgB;CACpD,CAAC;CAGD,OAAO;EAAE;EAAW;EAAc;EAAc;EAAU,gBAFnC,UAAU,WAAY,UAAU,UAAU,OAAQ,IAEf;EAAgB,cADrD,UAAU,WAAW;GAAE,GAAG,UAAU;GAAG,GAAG,UAAU;EAAE,IAAI,IACL;CAAa;AACzF"}

package/dist/canvas/useCanvasHandle.js

@@ -0,0 +1,69 @@
+import { useCallback, useImperativeHandle } from "react";
+
+//#region src/canvas/useCanvasHandle.ts
+/** The bare canvas's imperative handle. Its own-frame members answer against `frame`. */
+function useCanvasHandle(ref, target, frame, api) {
+	const { canvasRef, ownCanvasRef, detached, paintRectRef, inputElement, paintCanvas } = target;
+	const { viewRef, dimsRef, helpersRef } = frame;
+	const { hitTestExtrasIn, clientToWorld, requestRedraw, subscribeFrame, subscribeBeforePaint, subscribeResume, registerLayer, getView, setView, subscribeView, getPaintedVersion, paintedCursor, cursorSink, getDebug } = api;
+	const hitTestExtras = useCallback((worldX, worldY, at) => hitTestExtrasIn(worldX, worldY, at?.view ?? viewRef.current, at?.dims ?? dimsRef.current, helpersRef.current), [
+		hitTestExtrasIn,
+		dimsRef,
+		viewRef,
+		helpersRef
+	]);
+	const getSurfaceRect = useCallback(() => {
+		const origin = paintRectRef.current;
+		const { width: w, height: h } = dimsRef.current;
+		return {
+			x: origin?.x ?? 0,
+			y: origin?.y ?? 0,
+			width: w,
+			height: h
+		};
+	}, [dimsRef, paintRectRef]);
+	useImperativeHandle(ref, () => ({
+		element: detached ? inputElement ?? null : canvasRef.current,
+		surface: detached ? paintCanvas ?? null : ownCanvasRef.current,
+		getSurfaceRect,
+		clientToWorld,
+		requestRedraw,
+		subscribeFrame,
+		subscribeBeforePaint,
+		subscribeResume,
+		registerLayer,
+		hitTestExtras,
+		getView,
+		setView,
+		subscribeView,
+		getPaintedVersion,
+		paintedCursor,
+		cursorSink,
+		getDebug
+	}), [
+		canvasRef,
+		ownCanvasRef,
+		detached,
+		inputElement,
+		paintCanvas,
+		getSurfaceRect,
+		clientToWorld,
+		requestRedraw,
+		subscribeFrame,
+		subscribeBeforePaint,
+		subscribeResume,
+		registerLayer,
+		hitTestExtras,
+		getView,
+		setView,
+		subscribeView,
+		getPaintedVersion,
+		paintedCursor,
+		cursorSink,
+		getDebug
+	]);
+}
+
+//#endregion
+export { useCanvasHandle };
+//# sourceMappingURL=useCanvasHandle.js.map

package/dist/canvas/useCanvasHandle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasHandle.js","names":[],"sources":["../../src/canvas/useCanvasHandle.ts"],"sourcesContent":["import { useCallback, useImperativeHandle } from 'react';\nimport type React from 'react';\nimport type { View } from 'core/viewport/view';\nimport type { Dims } from 'core/layers/render';\nimport type { CanvasExtensionApi } from './canvasExtension';\nimport type { CanvasElements } from './useCanvasElements';\nimport type { HitTestExtrasIn } from './useExtraLayers';\nimport type { SurfaceFrame } from './useViewRegistrySurface';\n\n/** The handle's members the canvas builds elsewhere. */\nexport type CanvasHandleApi = Omit<\n  CanvasExtensionApi,\n  'element' | 'surface' | 'getSurfaceRect' | 'hitTestExtras' | 'ingest' | 'addView'\n> & { hitTestExtrasIn: HitTestExtrasIn };\n\n/** The elements the handle names, as of this render. */\nexport interface CanvasHandleTarget\n  extends Pick<CanvasElements, 'canvasRef' | 'ownCanvasRef' | 'detached' | 'paintRectRef'> {\n  inputElement: HTMLElement | null | undefined;\n  paintCanvas: HTMLCanvasElement | null | undefined;\n}\n\n/** The bare canvas's imperative handle. Its own-frame members answer against `frame`. */\nexport function useCanvasHandle(\n  ref: React.ForwardedRef<CanvasExtensionApi>,\n  target: CanvasHandleTarget,\n  frame: SurfaceFrame,\n  api: CanvasHandleApi,\n): void {\n  const { canvasRef, ownCanvasRef, detached, paintRectRef, inputElement, paintCanvas } = target;\n  const { viewRef, dimsRef, helpersRef } = frame;\n  const {\n    hitTestExtrasIn, clientToWorld, requestRedraw, subscribeFrame, subscribeBeforePaint,\n    subscribeResume, registerLayer, getView, setView, subscribeView,\n    getPaintedVersion, paintedCursor, cursorSink, getDebug,\n  } = api;\n\n  const hitTestExtras = useCallback((worldX: number, worldY: number, at?: { view: View; dims: Dims }) => (\n    hitTestExtrasIn(worldX, worldY, at?.view ?? viewRef.current, at?.dims ?? dimsRef.current, helpersRef.current)\n  ), [hitTestExtrasIn, dimsRef, viewRef, helpersRef]);\n\n  const getSurfaceRect = useCallback(() => {\n    const origin = paintRectRef.current;\n    const { width: w, height: h } = dimsRef.current;\n    return { x: origin?.x ?? 0, y: origin?.y ?? 0, width: w, height: h };\n  }, [dimsRef, paintRectRef]);\n\n  useImperativeHandle(ref, () => ({\n    // Named rather than read off `canvasRef` so the handle rebuilds when a\n    // detached surface's input element arrives, which is a render later.\n    element: detached ? inputElement ?? null : canvasRef.current,\n    surface: detached ? paintCanvas ?? null : ownCanvasRef.current,\n    getSurfaceRect,\n    clientToWorld,\n    requestRedraw,\n    subscribeFrame,\n    subscribeBeforePaint,\n    subscribeResume,\n    registerLayer,\n    hitTestExtras,\n    getView,\n    setView,\n    subscribeView,\n    getPaintedVersion,\n    paintedCursor,\n    cursorSink,\n    getDebug,\n  }), [canvasRef, ownCanvasRef, detached, inputElement, paintCanvas,\n       getSurfaceRect, clientToWorld, requestRedraw, subscribeFrame, subscribeBeforePaint, subscribeResume,\n       registerLayer,\n       hitTestExtras, getView, setView, subscribeView, getPaintedVersion,\n       paintedCursor, cursorSink, getDebug]);\n}\n"],"mappings":";;;;AAuBA,SAAgB,gBACd,KACA,QACA,OACA,KACM;CACN,MAAM,EAAE,WAAW,cAAc,UAAU,cAAc,cAAc,gBAAgB;CACvF,MAAM,EAAE,SAAS,SAAS,eAAe;CACzC,MAAM,EACJ,iBAAiB,eAAe,eAAe,gBAAgB,sBAC/D,iBAAiB,eAAe,SAAS,SAAS,eAClD,mBAAmB,eAAe,YAAY,aAC5C;CAEJ,MAAM,gBAAgB,aAAa,QAAgB,QAAgB,OACjE,gBAAgB,QAAQ,QAAQ,IAAI,QAAQ,QAAQ,SAAS,IAAI,QAAQ,QAAQ,SAAS,WAAW,OAAO,GAC3G;EAAC;EAAiB;EAAS;EAAS;CAAU,CAAC;CAElD,MAAM,iBAAiB,kBAAkB;EACvC,MAAM,SAAS,aAAa;EAC5B,MAAM,EAAE,OAAO,GAAG,QAAQ,MAAM,QAAQ;EACxC,OAAO;GAAE,GAAG,QAAQ,KAAK;GAAG,GAAG,QAAQ,KAAK;GAAG,OAAO;GAAG,QAAQ;EAAE;CACrE,GAAG,CAAC,SAAS,YAAY,CAAC;CAE1B,oBAAoB,YAAY;EAG9B,SAAS,WAAW,gBAAgB,OAAO,UAAU;EACrD,SAAS,WAAW,eAAe,OAAO,aAAa;EACvD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF,IAAI;EAAC;EAAW;EAAc;EAAU;EAAc;EACjD;EAAgB;EAAe;EAAe;EAAgB;EAAsB;EACpF;EACA;EAAe;EAAS;EAAS;EAAe;EAChD;EAAe;EAAY;CAAQ,CAAC;AAC3C"}

package/dist/canvas/useCanvasPaint.js

@@ -0,0 +1,91 @@
+import { DEFAULT_LAYER_RETAIN } from "../core/layers/retain.js";
+import { drawLayers } from "../core/layers/render.js";
+import { beginDebugFrame } from "../debug/useDebugSink.js";
+import { NO_LAYER_VISIBILITY } from "./useExtraLayers.js";
+import { viewToMat3 } from "@weasel-js/renderer";
+import { useCallback, useEffect, useInsertionEffect, useRef } from "react";
+import { useLatest } from "@weasel-js/react";
+
+//#region src/canvas/useCanvasPaint.ts
+/**
+* Which content version the last paint showed. `markPainted` records the current one, read
+* from `contentVersion`'s latest committed value.
+*/
+function usePaintedVersion(contentVersion) {
+	const contentVersionRef = useLatest(contentVersion);
+	const paintedVersionRef = useRef(0);
+	return {
+		getPaintedVersion: useCallback(() => paintedVersionRef.current, []),
+		markPainted: useCallback(() => {
+			paintedVersionRef.current = contentVersionRef.current?.() ?? 0;
+		}, [contentVersionRef])
+	};
+}
+function retainPolicy(retain) {
+	if (retain === false) return false;
+	const minCommands = retain?.minCommands;
+	return minCommands === void 0 ? DEFAULT_LAYER_RETAIN : { minCommands };
+}
+/**
+* Publish the canvas's paint into `paintRef`, which the frame loop calls. The paint binds the
+* leased renderer to whichever canvas pixels go to and draws the layer stack through the
+* current view. The layer command cache lives as long as the canvas.
+*/
+function useCanvasPaint(paintRef, lease, target, frame, markPainted) {
+	const { paintTargetRef, ownCanvasRef, paintRectRef } = target;
+	const { inputsRef, viewRef, gateRef, helpersRef } = frame;
+	const layerCacheRef = useRef(/* @__PURE__ */ new Map());
+	const paint = useCallback(() => {
+		const c = paintTargetRef.current ?? ownCanvasRef.current;
+		if (!c) return false;
+		const rect = paintRectRef.current;
+		const { layers: paintLayers, width: w, height: h, debugSink: sink, frameStats: timed, dpr: dprIn, flattenTolerance: paintFlattenTolerance, layerGroups: groups, shaders: paintShaders, retain } = inputsRef.current;
+		if (w === 0 || h === 0) return false;
+		const debugFrame = beginDebugFrame(sink, timed, paintLayers);
+		const renderer = lease.bind(c, {
+			width: w,
+			height: h,
+			dpr: dprIn
+		}, {
+			tile: rect,
+			flattenTolerance: paintFlattenTolerance,
+			retainBudget: retain ? retain.budget : void 0,
+			shaders: paintShaders
+		});
+		if (!renderer) return false;
+		const view = viewRef.current;
+		const { layerVisibility: vis, layerOrder: order } = gateRef.current;
+		const spans = debugFrame?.time();
+		const commands = drawLayers(paintLayers, helpersRef.current, vis ?? NO_LAYER_VISIBILITY, order, view, {
+			width: w,
+			height: h
+		}, layerCacheRef.current, void 0, groups, spans, retainPolicy(retain));
+		renderer.render(commands, viewToMat3(view), spans ? { spans } : void 0);
+		debugFrame?.end(renderer.lastFrameStats());
+		markPainted();
+		return true;
+	}, [
+		gateRef,
+		helpersRef,
+		inputsRef,
+		lease,
+		markPainted,
+		ownCanvasRef,
+		paintRectRef,
+		paintTargetRef,
+		viewRef
+	]);
+	useInsertionEffect(() => {
+		paintRef.current = paint;
+	});
+	useEffect(() => {
+		const layerCache = layerCacheRef.current;
+		return () => {
+			layerCache.clear();
+		};
+	}, []);
+}
+
+//#endregion
+export { useCanvasPaint, usePaintedVersion };
+//# sourceMappingURL=useCanvasPaint.js.map

package/dist/canvas/useCanvasPaint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasPaint.js","names":[],"sources":["../../src/canvas/useCanvasPaint.ts"],"sourcesContent":["import { useCallback, useEffect, useInsertionEffect, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { viewToMat3 } from '@weasel-js/renderer';\nimport type { View } from 'core/viewport/view';\nimport {\n  DEFAULT_LAYER_RETAIN, drawLayers, type LayerCommandCache, type LayerRetainPolicy, type RenderLayer,\n} from 'core/layers/render';\nimport type { CanvasDebugSink } from '../debug/types';\nimport { beginDebugFrame } from '../debug/useDebugSink';\nimport type { CanvasRendererLease } from './canvasRenderer';\nimport type { CanvasProps } from './canvasProps';\nimport type { CanvasElements } from './useCanvasElements';\nimport { NO_LAYER_VISIBILITY, type LayerGate } from './useExtraLayers';\n\n/** What a frame's paint reads that a React render owns. */\nexport interface PaintInputs extends Pick<CanvasProps<unknown>, 'dpr' | 'layerGroups' | 'shaders' | 'flattenTolerance' | 'retain'> {\n  layers: RenderLayer<unknown>[];\n  width: number;\n  height: number;\n  debugSink: CanvasDebugSink | null;\n  frameStats: boolean;\n}\n\n/** What a frame's paint reads that changes outside a render. */\nexport interface PaintFrame {\n  inputsRef: { readonly current: PaintInputs };\n  viewRef: { readonly current: View };\n  gateRef: { readonly current: LayerGate };\n  helpersRef: { readonly current: unknown };\n}\n\n/**\n * Which content version the last paint showed. `markPainted` records the current one, read\n * from `contentVersion`'s latest committed value.\n */\nexport function usePaintedVersion(contentVersion: (() => number) | undefined): {\n  getPaintedVersion: () => number;\n  markPainted: () => void;\n} {\n  const contentVersionRef = useLatest(contentVersion);\n  const paintedVersionRef = useRef(0);\n  const getPaintedVersion = useCallback(() => paintedVersionRef.current, []);\n  const markPainted = useCallback(() => {\n    paintedVersionRef.current = contentVersionRef.current?.() ?? 0;\n  }, [contentVersionRef]);\n  return { getPaintedVersion, markPainted };\n}\n\nfunction retainPolicy(retain: PaintInputs['retain']): LayerRetainPolicy | false {\n  if (retain === false) return false;\n  const minCommands = retain?.minCommands;\n  return minCommands === undefined ? DEFAULT_LAYER_RETAIN : { minCommands };\n}\n\n/**\n * Publish the canvas's paint into `paintRef`, which the frame loop calls. The paint binds the\n * leased renderer to whichever canvas pixels go to and draws the layer stack through the\n * current view. The layer command cache lives as long as the canvas.\n */\nexport function useCanvasPaint(\n  paintRef: { current: () => boolean },\n  lease: CanvasRendererLease,\n  target: Pick<CanvasElements, 'paintTargetRef' | 'ownCanvasRef' | 'paintRectRef'>,\n  frame: PaintFrame,\n  markPainted: () => void,\n): void {\n  const { paintTargetRef, ownCanvasRef, paintRectRef } = target;\n  const { inputsRef, viewRef, gateRef, helpersRef } = frame;\n  const layerCacheRef = useRef<LayerCommandCache>(new Map());\n\n  const paint = useCallback((): boolean => {\n    const c = paintTargetRef.current ?? ownCanvasRef.current;\n    if (!c) return false;\n    const rect = paintRectRef.current;\n    const {\n      layers: paintLayers, width: w, height: h, debugSink: sink, frameStats: timed,\n      dpr: dprIn,\n      flattenTolerance: paintFlattenTolerance,\n      layerGroups: groups, shaders: paintShaders, retain,\n    } = inputsRef.current;\n    if (w === 0 || h === 0) return false;\n\n    const debugFrame = beginDebugFrame(sink, timed, paintLayers);\n\n    const renderer = lease.bind(c, { width: w, height: h, dpr: dprIn }, {\n      tile: rect,\n      flattenTolerance: paintFlattenTolerance,\n      retainBudget: retain ? retain.budget : undefined,\n      shaders: paintShaders,\n    });\n    // No WebGL2 (jsdom), or a context that is lost for now: nothing to paint.\n    if (!renderer) return false;\n\n    const view = viewRef.current;\n    const { layerVisibility: vis, layerOrder: order } = gateRef.current;\n    const spans = debugFrame?.time();\n    const commands = drawLayers(\n      paintLayers,\n      helpersRef.current,\n      vis ?? NO_LAYER_VISIBILITY,\n      order,\n      view,\n      { width: w, height: h },\n      layerCacheRef.current,\n      undefined,\n      groups,\n      spans,\n      retainPolicy(retain),\n    );\n    renderer.render(commands, viewToMat3(view), spans ? { spans } : undefined);\n    debugFrame?.end(renderer.lastFrameStats());\n    markPainted();\n    return true;\n  }, [gateRef, helpersRef, inputsRef, lease, markPainted, ownCanvasRef, paintRectRef, paintTargetRef, viewRef]);\n  useInsertionEffect(() => {\n    paintRef.current = paint;\n  });\n\n  useEffect(() => {\n    const layerCache = layerCacheRef.current;\n    return () => { layerCache.clear(); };\n  }, []);\n}\n"],"mappings":";;;;;;;;;;;;;AAmCA,SAAgB,kBAAkB,gBAGhC;CACA,MAAM,oBAAoB,UAAU,cAAc;CAClD,MAAM,oBAAoB,OAAO,CAAC;CAKlC,OAAO;EAAE,mBAJiB,kBAAkB,kBAAkB,SAAS,CAAC,CAI/D;EAAmB,aAHR,kBAAkB;GACpC,kBAAkB,UAAU,kBAAkB,UAAU,KAAK;EAC/D,GAAG,CAAC,iBAAiB,CACO;CAAY;AAC1C;AAEA,SAAS,aAAa,QAA0D;CAC9E,IAAI,WAAW,OAAO,OAAO;CAC7B,MAAM,cAAc,QAAQ;CAC5B,OAAO,gBAAgB,SAAY,uBAAuB,EAAE,YAAY;AAC1E;;;;;;AAOA,SAAgB,eACd,UACA,OACA,QACA,OACA,aACM;CACN,MAAM,EAAE,gBAAgB,cAAc,iBAAiB;CACvD,MAAM,EAAE,WAAW,SAAS,SAAS,eAAe;CACpD,MAAM,gBAAgB,uBAA0B,IAAI,IAAI,CAAC;CAEzD,MAAM,QAAQ,kBAA2B;EACvC,MAAM,IAAI,eAAe,WAAW,aAAa;EACjD,IAAI,CAAC,GAAG,OAAO;EACf,MAAM,OAAO,aAAa;EAC1B,MAAM,EACJ,QAAQ,aAAa,OAAO,GAAG,QAAQ,GAAG,WAAW,MAAM,YAAY,OACvE,KAAK,OACL,kBAAkB,uBAClB,aAAa,QAAQ,SAAS,cAAc,WAC1C,UAAU;EACd,IAAI,MAAM,KAAK,MAAM,GAAG,OAAO;EAE/B,MAAM,aAAa,gBAAgB,MAAM,OAAO,WAAW;EAE3D,MAAM,WAAW,MAAM,KAAK,GAAG;GAAE,OAAO;GAAG,QAAQ;GAAG,KAAK;EAAM,GAAG;GAClE,MAAM;GACN,kBAAkB;GAClB,cAAc,SAAS,OAAO,SAAS;GACvC,SAAS;EACX,CAAC;EAED,IAAI,CAAC,UAAU,OAAO;EAEtB,MAAM,OAAO,QAAQ;EACrB,MAAM,EAAE,iBAAiB,KAAK,YAAY,UAAU,QAAQ;EAC5D,MAAM,QAAQ,YAAY,KAAK;EAC/B,MAAM,WAAW,WACf,aACA,WAAW,SACX,OAAO,qBACP,OACA,MACA;GAAE,OAAO;GAAG,QAAQ;EAAE,GACtB,cAAc,SACd,QACA,QACA,OACA,aAAa,MAAM,CACrB;EACA,SAAS,OAAO,UAAU,WAAW,IAAI,GAAG,QAAQ,EAAE,MAAM,IAAI,MAAS;EACzE,YAAY,IAAI,SAAS,eAAe,CAAC;EACzC,YAAY;EACZ,OAAO;CACT,GAAG;EAAC;EAAS;EAAY;EAAW;EAAO;EAAa;EAAc;EAAc;EAAgB;CAAO,CAAC;CAC5G,yBAAyB;EACvB,SAAS,UAAU;CACrB,CAAC;CAED,gBAAgB;EACd,MAAM,aAAa,cAAc;EACjC,aAAa;GAAE,WAAW,MAAM;EAAG;CACrC,GAAG,CAAC,CAAC;AACP"}

package/dist/canvas/useCanvasRenderer.js

@@ -1,31 +1,53 @@
-import { watchDevicePixelRatio as e } from "../core/device/watchDevicePixelRatio.js";
-import { leaseCanvasRenderer as t, shaderKeyOf as n } from "./canvasRenderer.js";
-import { getProgramSource as r, programSourceRegistry as i } from "@weasel-js/renderer";
-import { useEffect as a, useState as o } from "react";
+import { watchDevicePixelRatio } from "../core/device/watchDevicePixelRatio.js";
+import { leaseCanvasRenderer, shaderKeyOf } from "./canvasRenderer.js";
+import { getProgramSource, programSourceRegistry } from "@weasel-js/renderer";
+import { useEffect, useState } from "react";
+
 //#region src/canvas/useCanvasRenderer.ts
-function s() {
-	let [e] = o(t);
-	return a(() => () => e.release(), [e]), e;
+/**
+* The React lifetime of `leaseCanvasRenderer`: a stable lease for the
+* component's canvas, whose renderer and GL objects are freed on unmount.
+* Every canvas surface in core paints through this, so none can skip the
+* teardown.
+*/
+function useCanvasRenderer() {
+	const [lease] = useState(leaseCanvasRenderer);
+	useEffect(() => () => lease.release(), [lease]);
+	return lease;
 }
-function c(e, t) {
-	a(() => e.subscribeRestored(t), [e, t]);
+/** Repaint a surface when its canvas gets a lost GL context back. */
+function useRedrawOnRestore(lease, requestRedraw) {
+	useEffect(() => lease.subscribeRestored(requestRedraw), [lease, requestRedraw]);
 }
-function l(t, n) {
-	let r = n === void 0;
-	a(() => r ? e(() => t()) : void 0, [r, t]);
+/**
+* Repaint a surface that follows the ambient density when `devicePixelRatio`
+* changes. The lease reads the ratio at each paint, and nothing else asks for
+* one. A surface given its own `dpr` passes it here and is left alone.
+*/
+function useRedrawOnDensityChange(requestRedraw, dpr) {
+	const ambient = dpr === void 0;
+	useEffect(() => ambient ? watchDevicePixelRatio(() => requestRedraw()) : void 0, [ambient, requestRedraw]);
 }
-function u(e, t) {
-	let o = n(e);
-	a(() => {
-		if (!o) return;
-		let e = o.split("|"), n = e.map(r);
-		return i.subscribe(() => {
-			let i = e.map(r), a = i.some((e, t) => e !== n[t]);
-			n = i, a && t();
+/**
+* Repaint a surface when one of its custom programs is re-registered with new
+* source. The renderer recompiles on the frame that draws it, and nothing else
+* asks for that frame.
+*/
+function useRedrawOnShaderSource(shaders, requestRedraw) {
+	const key = shaderKeyOf(shaders);
+	useEffect(() => {
+		if (!key) return;
+		const ids = key.split("|");
+		let seen = ids.map(getProgramSource);
+		return programSourceRegistry.subscribe(() => {
+			const now = ids.map(getProgramSource);
+			const changed = now.some((src, i) => src !== seen[i]);
+			seen = now;
+			if (changed) requestRedraw();
 		});
-	}, [o, t]);
+	}, [key, requestRedraw]);
 }
-//#endregion
-export { s as useCanvasRenderer, l as useRedrawOnDensityChange, c as useRedrawOnRestore, u as useRedrawOnShaderSource };
 
+//#endregion
+export { useCanvasRenderer, useRedrawOnDensityChange, useRedrawOnRestore, useRedrawOnShaderSource };
 //# sourceMappingURL=useCanvasRenderer.js.map

package/dist/canvas/useCanvasRenderer.js.map

@@ -1 +1 @@
-{"version":3,"file":"useCanvasRenderer.js","names":["useCanvasRenderer","lease","useState","leaseCanvasRenderer","useEffect","useRedrawOnRestore","requestRedraw","useRedrawOnDensityChange","ambient","dpr","watchDevicePixelRatio","useRedrawOnShaderSource","key","shaderKeyOf","shaders","ids","seen","getProgramSource","programSourceRegistry","now","changed","src","i"],"sources":["../../src/canvas/useCanvasRenderer.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport { watchDevicePixelRatio } from '../core/device/watchDevicePixelRatio';\nimport { getProgramSource, programSourceRegistry, type ShaderProgramHandle } from '@weasel-js/renderer';\nimport { leaseCanvasRenderer, shaderKeyOf, type CanvasRendererLease } from './canvasRenderer';\n\n/**\n * The React lifetime of `leaseCanvasRenderer`: a stable lease for the\n * component's canvas, whose renderer and GL objects are freed on unmount.\n * Every canvas surface in core paints through this, so none can skip the\n * teardown.\n */\nexport function useCanvasRenderer(): CanvasRendererLease {\n  const [lease] = useState(leaseCanvasRenderer);\n  useEffect(() => () => lease.release(), [lease]);\n  return lease;\n}\n\n/** Repaint a surface when its canvas gets a lost GL context back. */\nexport function useRedrawOnRestore(lease: CanvasRendererLease, requestRedraw: () => void): void {\n  useEffect(() => lease.subscribeRestored(requestRedraw), [lease, requestRedraw]);\n}\n\n/**\n * Repaint a surface that follows the ambient density when `devicePixelRatio`\n * changes. The lease reads the ratio at each paint, and nothing else asks for\n * one. A surface given its own `dpr` passes it here and is left alone.\n */\nexport function useRedrawOnDensityChange(requestRedraw: () => void, dpr?: number): void {\n  const ambient = dpr === undefined;\n  useEffect(() => (ambient ? watchDevicePixelRatio(() => requestRedraw()) : undefined), [ambient, requestRedraw]);\n}\n\n/**\n * Repaint a surface when one of its custom programs is re-registered with new\n * source. The renderer recompiles on the frame that draws it, and nothing else\n * asks for that frame.\n */\nexport function useRedrawOnShaderSource(\n  shaders: readonly ShaderProgramHandle[] | undefined,\n  requestRedraw: () => void,\n): void {\n  const key = shaderKeyOf(shaders);\n  useEffect(() => {\n    if (!key) return;\n    const ids = key.split('|');\n    let seen = ids.map(getProgramSource);\n    return programSourceRegistry.subscribe(() => {\n      const now = ids.map(getProgramSource);\n      const changed = now.some((src, i) => src !== seen[i]);\n      seen = now;\n      if (changed) requestRedraw();\n    });\n  }, [key, requestRedraw]);\n}\n"],"mappings":";;;;;AAWA,SAAgBA,IAAyC;CACvD,IAAM,CAACC,KAASC,EAASC,CAAmB;CAE5C,OADAC,cAAsBH,EAAM,QAAQ,GAAG,CAACA,CAAK,CAAC,GACvCA;AACT;AAGA,SAAgBI,EAAmB,GAA4B,GAAiC;CAC9F,QAAgBJ,EAAM,kBAAkBK,CAAa,GAAG,CAACL,GAAOK,CAAa,CAAC;AAChF;AAOA,SAAgBC,EAAyB,GAA2B,GAAoB;CACtF,IAAMC,IAAUC,MAAQ,KAAA;CACxB,QAAiBD,IAAUE,QAA4BJ,EAAc,CAAC,IAAI,KAAA,GAAY,CAACE,GAASF,CAAa,CAAC;AAChH;AAOA,SAAgBK,EACd,GACA,GACM;CACN,IAAMC,IAAMC,EAAYC,CAAO;CAC/B,QAAgB;EACd,IAAI,CAACF,GAAK;EACV,IAAMG,IAAMH,EAAI,MAAM,GAAG,GACrBI,IAAOD,EAAI,IAAIE,CAAgB;EACnC,OAAOC,EAAsB,gBAAgB;GAC3C,IAAMC,IAAMJ,EAAI,IAAIE,CAAgB,GAC9BG,IAAUD,EAAI,MAAM,GAAK,MAAME,MAAQL,EAAKM,EAAE;GAEpD,AADA,IAAOH,GACHC,KAASd,EAAc;EAC7B,CAAC;CACH,GAAG,CAACM,GAAKN,CAAa,CAAC;AACzB"}
+{"version":3,"file":"useCanvasRenderer.js","names":[],"sources":["../../src/canvas/useCanvasRenderer.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport { watchDevicePixelRatio } from '../core/device/watchDevicePixelRatio';\nimport { getProgramSource, programSourceRegistry, type ShaderProgramHandle } from '@weasel-js/renderer';\nimport { leaseCanvasRenderer, shaderKeyOf, type CanvasRendererLease } from './canvasRenderer';\n\n/**\n * The React lifetime of `leaseCanvasRenderer`: a stable lease for the\n * component's canvas, whose renderer and GL objects are freed on unmount.\n * Every canvas surface in core paints through this, so none can skip the\n * teardown.\n */\nexport function useCanvasRenderer(): CanvasRendererLease {\n  const [lease] = useState(leaseCanvasRenderer);\n  useEffect(() => () => lease.release(), [lease]);\n  return lease;\n}\n\n/** Repaint a surface when its canvas gets a lost GL context back. */\nexport function useRedrawOnRestore(lease: CanvasRendererLease, requestRedraw: () => void): void {\n  useEffect(() => lease.subscribeRestored(requestRedraw), [lease, requestRedraw]);\n}\n\n/**\n * Repaint a surface that follows the ambient density when `devicePixelRatio`\n * changes. The lease reads the ratio at each paint, and nothing else asks for\n * one. A surface given its own `dpr` passes it here and is left alone.\n */\nexport function useRedrawOnDensityChange(requestRedraw: () => void, dpr?: number): void {\n  const ambient = dpr === undefined;\n  useEffect(() => (ambient ? watchDevicePixelRatio(() => requestRedraw()) : undefined), [ambient, requestRedraw]);\n}\n\n/**\n * Repaint a surface when one of its custom programs is re-registered with new\n * source. The renderer recompiles on the frame that draws it, and nothing else\n * asks for that frame.\n */\nexport function useRedrawOnShaderSource(\n  shaders: readonly ShaderProgramHandle[] | undefined,\n  requestRedraw: () => void,\n): void {\n  const key = shaderKeyOf(shaders);\n  useEffect(() => {\n    if (!key) return;\n    const ids = key.split('|');\n    let seen = ids.map(getProgramSource);\n    return programSourceRegistry.subscribe(() => {\n      const now = ids.map(getProgramSource);\n      const changed = now.some((src, i) => src !== seen[i]);\n      seen = now;\n      if (changed) requestRedraw();\n    });\n  }, [key, requestRedraw]);\n}\n"],"mappings":";;;;;;;;;;;;AAWA,SAAgB,oBAAyC;CACvD,MAAM,CAAC,SAAS,SAAS,mBAAmB;CAC5C,sBAAsB,MAAM,QAAQ,GAAG,CAAC,KAAK,CAAC;CAC9C,OAAO;AACT;;AAGA,SAAgB,mBAAmB,OAA4B,eAAiC;CAC9F,gBAAgB,MAAM,kBAAkB,aAAa,GAAG,CAAC,OAAO,aAAa,CAAC;AAChF;;;;;;AAOA,SAAgB,yBAAyB,eAA2B,KAAoB;CACtF,MAAM,UAAU,QAAQ;CACxB,gBAAiB,UAAU,4BAA4B,cAAc,CAAC,IAAI,QAAY,CAAC,SAAS,aAAa,CAAC;AAChH;;;;;;AAOA,SAAgB,wBACd,SACA,eACM;CACN,MAAM,MAAM,YAAY,OAAO;CAC/B,gBAAgB;EACd,IAAI,CAAC,KAAK;EACV,MAAM,MAAM,IAAI,MAAM,GAAG;EACzB,IAAI,OAAO,IAAI,IAAI,gBAAgB;EACnC,OAAO,sBAAsB,gBAAgB;GAC3C,MAAM,MAAM,IAAI,IAAI,gBAAgB;GACpC,MAAM,UAAU,IAAI,MAAM,KAAK,MAAM,QAAQ,KAAK,EAAE;GACpD,OAAO;GACP,IAAI,SAAS,cAAc;EAC7B,CAAC;CACH,GAAG,CAAC,KAAK,aAAa,CAAC;AACzB"}

package/dist/canvas/useCanvasSurface.js

@@ -1,31 +1,49 @@
-import { useCanvasRenderer as e, useRedrawOnDensityChange as t, useRedrawOnRestore as n, useRedrawOnShaderSource as r } from "./useCanvasRenderer.js";
-import { useFrameLoop as i } from "./useFrameLoop.js";
-import { useLateContentRedraw as a } from "./useLateContentRedraw.js";
-import { useRedrawOn as o } from "./useRedrawOn.js";
-import { useEffect as s, useLayoutEffect as c, useRef as l } from "react";
+import { useCanvasRenderer, useRedrawOnDensityChange, useRedrawOnRestore, useRedrawOnShaderSource } from "./useCanvasRenderer.js";
+import { useFrameLoop } from "./useFrameLoop.js";
+import { useLateContentRedraw } from "./useLateContentRedraw.js";
+import { useRedrawOn } from "./useRedrawOn.js";
+import { useEffect, useLayoutEffect, useRef } from "react";
+
 //#region src/canvas/useCanvasSurface.ts
-function u(s, c = {}) {
-	let l = e(), u = i(() => s(l), c), { requestRedraw: f } = u;
-	return n(l, f), t(f, c.dpr), a(f), r(c.shaders, f), o(c.redrawOn, f), d(c.paintOnCommit === !0, () => s(l), f), {
-		...u,
-		lease: l
+/**
+* Everything a canvas surface in core needs around its paint: the renderer
+* lease, the frame loop, and a repaint for each thing that changes pixels with
+* no React render behind it — a restored GL context, a density change, late
+* content, a re-registered shader, and the caller's own `redrawOn` sources.
+*
+* @param paint As `useFrameLoop`'s, handed the lease to draw through.
+*/
+function useCanvasSurface(paint, options = {}) {
+	const lease = useCanvasRenderer();
+	const loop = useFrameLoop(() => paint(lease), options);
+	const { requestRedraw } = loop;
+	useRedrawOnRestore(lease, requestRedraw);
+	useRedrawOnDensityChange(requestRedraw, options.dpr);
+	useLateContentRedraw(requestRedraw);
+	useRedrawOnShaderSource(options.shaders, requestRedraw);
+	useRedrawOn(options.redrawOn, requestRedraw);
+	useRedrawOnCommit(options.onCommit, () => paint(lease), requestRedraw);
+	return {
+		...loop,
+		lease
 	};
 }
-function d(e, t, n) {
-	let r = l(!1);
-	c(() => {
-		if (e) {
-			if (r.current) {
-				n();
-				return;
-			}
-			r.current = t(), r.current || n();
+function useRedrawOnCommit(mode, paintNow, requestRedraw) {
+	const paintedRef = useRef(false);
+	useLayoutEffect(() => {
+		if (!mode) return;
+		if (mode === "redraw" || paintedRef.current) {
+			requestRedraw();
+			return;
 		}
-	}), s(() => () => {
-		r.current = !1;
+		paintedRef.current = paintNow();
+		if (!paintedRef.current) requestRedraw();
+	});
+	useEffect(() => () => {
+		paintedRef.current = false;
 	}, []);
 }
-//#endregion
-export { u as useCanvasSurface };
 
+//#endregion
+export { useCanvasSurface };
 //# sourceMappingURL=useCanvasSurface.js.map

package/dist/canvas/useCanvasSurface.js.map

@@ -1 +1 @@
-{"version":3,"file":"useCanvasSurface.js","names":["useCanvasSurface","lease","useCanvasRenderer","loop","useFrameLoop","paint","options","useRedrawOnRestore","requestRedraw","useRedrawOnDensityChange","useLateContentRedraw","useRedrawOnShaderSource","useRedrawOn","usePaintOnCommit","paintedRef","useRef","useLayoutEffect","on","paintNow","useEffect"],"sources":["../../src/canvas/useCanvasSurface.ts"],"sourcesContent":["import { useEffect, useLayoutEffect, useRef } from 'react';\nimport type { ShaderProgramHandle } from '@weasel-js/renderer';\nimport type { RedrawSource } from '../core/layers/render';\nimport type { CanvasRendererLease } from './canvasRenderer';\nimport {\n  useCanvasRenderer, useRedrawOnDensityChange, useRedrawOnRestore, useRedrawOnShaderSource,\n} from './useCanvasRenderer';\nimport { useFrameLoop, type FrameLoop, type FrameLoopOptions } from './useFrameLoop';\nimport { useLateContentRedraw } from './useLateContentRedraw';\nimport { useRedrawOn } from './useRedrawOn';\n\n/** What a surface tells {@link useCanvasSurface} about itself, beyond its paint. */\nexport interface CanvasSurfaceOptions extends FrameLoopOptions {\n  /** The surface's own density. Omit to follow `devicePixelRatio`. */\n  dpr?: number;\n  /** External state the paint reads; each source repaints when it notifies. */\n  redrawOn?: readonly RedrawSource[];\n  /** Custom programs the paint draws with; new source for one repaints. */\n  shaders?: readonly ShaderProgramHandle[];\n  /** Mark the surface dirty on every committed render, and paint the first\n   *  one in place, in the caller's stack, so the first frame shown is the\n   *  content and not a blank canvas. For a surface whose paint reads its\n   *  props. */\n  paintOnCommit?: boolean;\n}\n\n/** A surface's frame loop and the renderer lease its paint draws through. */\nexport interface CanvasSurface extends FrameLoop {\n  lease: CanvasRendererLease;\n}\n\n/**\n * Everything a canvas surface in core needs around its paint: the renderer\n * lease, the frame loop, and a repaint for each thing that changes pixels with\n * no React render behind it — a restored GL context, a density change, late\n * content, a re-registered shader, and the caller's own `redrawOn` sources.\n *\n * @param paint As `useFrameLoop`'s, handed the lease to draw through.\n */\nexport function useCanvasSurface(\n  paint: (lease: CanvasRendererLease) => boolean,\n  options: CanvasSurfaceOptions = {},\n): CanvasSurface {\n  const lease = useCanvasRenderer();\n  const loop = useFrameLoop(() => paint(lease), options);\n  const { requestRedraw } = loop;\n  useRedrawOnRestore(lease, requestRedraw);\n  useRedrawOnDensityChange(requestRedraw, options.dpr);\n  useLateContentRedraw(requestRedraw);\n  useRedrawOnShaderSource(options.shaders, requestRedraw);\n  useRedrawOn(options.redrawOn, requestRedraw);\n  usePaintOnCommit(options.paintOnCommit === true, () => paint(lease), requestRedraw);\n  return { ...loop, lease };\n}\n\nfunction usePaintOnCommit(on: boolean, paintNow: () => boolean, requestRedraw: () => void): void {\n  const paintedRef = useRef(false);\n  // No dependency array: the paint reads whatever the render did.\n  useLayoutEffect(() => {\n    if (!on) return;\n    if (paintedRef.current) { requestRedraw(); return; }\n    paintedRef.current = paintNow();\n    if (!paintedRef.current) requestRedraw();\n  });\n  // The renderer is freed on unmount; a remount (StrictMode) paints its first\n  // frame in place again.\n  useEffect(() => () => { paintedRef.current = false; }, []);\n}\n"],"mappings":";;;;;;AAuCA,SAAgBA,EACd,GACA,IAAgC,CAAC,GAClB;CACf,IAAMC,IAAQC,EAAkB,GAC1BC,IAAOC,QAAmBC,EAAMJ,CAAK,GAAGK,CAAO,GAC/C,EAAE,qBAAkBH;CAO1B,OANAI,EAAmBN,GAAOO,CAAa,GACvCC,EAAyBD,GAAeF,EAAQ,GAAG,GACnDI,EAAqBF,CAAa,GAClCG,EAAwBL,EAAQ,SAASE,CAAa,GACtDI,EAAYN,EAAQ,UAAUE,CAAa,GAC3CK,EAAiBP,EAAQ,kBAAkB,UAAYD,EAAMJ,CAAK,GAAGO,CAAa,GAC3E;EAAE,GAAGL;EAAM;CAAM;AAC1B;AAEA,SAASU,EAAiB,GAAa,GAAyB,GAAiC;CAC/F,IAAMC,IAAaC,EAAO,EAAK;CAU/B,AARAC,QAAsB;EACpB,IAAKC,GACL;OAAIH,EAAW,SAAS;IAAE,EAAc;IAAG;GAAQ;GAEnD,AADA,EAAW,UAAUI,EAAS,GACzBJ,EAAW,WAASN,EAAc;EAFY;CAGrD,CAAC,GAGDW,cAAsB;EAAE,EAAW,UAAU;CAAO,GAAG,CAAC,CAAC;AAC3D"}
+{"version":3,"file":"useCanvasSurface.js","names":[],"sources":["../../src/canvas/useCanvasSurface.ts"],"sourcesContent":["import { useEffect, useLayoutEffect, useRef } from 'react';\nimport type { ShaderProgramHandle } from '@weasel-js/renderer';\nimport type { RedrawSource } from '../core/layers/render';\nimport type { CanvasRendererLease } from './canvasRenderer';\nimport {\n  useCanvasRenderer, useRedrawOnDensityChange, useRedrawOnRestore, useRedrawOnShaderSource,\n} from './useCanvasRenderer';\nimport { useFrameLoop, type FrameLoop, type FrameLoopOptions } from './useFrameLoop';\nimport { useLateContentRedraw } from './useLateContentRedraw';\nimport { useRedrawOn } from './useRedrawOn';\n\n/** What a surface tells {@link useCanvasSurface} about itself, beyond its paint. */\nexport interface CanvasSurfaceOptions extends FrameLoopOptions {\n  /** The surface's own density. Omit to follow `devicePixelRatio`. */\n  dpr?: number;\n  /** External state the paint reads; each source repaints when it notifies. */\n  redrawOn?: readonly RedrawSource[];\n  /** Custom programs the paint draws with; new source for one repaints. */\n  shaders?: readonly ShaderProgramHandle[];\n  /** Mark the surface dirty on every committed render, so a surface whose\n   *  paint reads its props cannot paint them stale. `'paint'` also paints the\n   *  first commit in place, in the caller's stack, so the first frame shown is\n   *  the content and not a blank canvas. */\n  onCommit?: 'redraw' | 'paint';\n}\n\n/** A surface's frame loop and the renderer lease its paint draws through. */\nexport interface CanvasSurface extends FrameLoop {\n  lease: CanvasRendererLease;\n}\n\n/**\n * Everything a canvas surface in core needs around its paint: the renderer\n * lease, the frame loop, and a repaint for each thing that changes pixels with\n * no React render behind it — a restored GL context, a density change, late\n * content, a re-registered shader, and the caller's own `redrawOn` sources.\n *\n * @param paint As `useFrameLoop`'s, handed the lease to draw through.\n */\nexport function useCanvasSurface(\n  paint: (lease: CanvasRendererLease) => boolean,\n  options: CanvasSurfaceOptions = {},\n): CanvasSurface {\n  const lease = useCanvasRenderer();\n  const loop = useFrameLoop(() => paint(lease), options);\n  const { requestRedraw } = loop;\n  useRedrawOnRestore(lease, requestRedraw);\n  useRedrawOnDensityChange(requestRedraw, options.dpr);\n  useLateContentRedraw(requestRedraw);\n  useRedrawOnShaderSource(options.shaders, requestRedraw);\n  useRedrawOn(options.redrawOn, requestRedraw);\n  useRedrawOnCommit(options.onCommit, () => paint(lease), requestRedraw);\n  return { ...loop, lease };\n}\n\nfunction useRedrawOnCommit(\n  mode: CanvasSurfaceOptions['onCommit'],\n  paintNow: () => boolean,\n  requestRedraw: () => void,\n): void {\n  const paintedRef = useRef(false);\n  // No dependency array: the paint reads whatever the render did.\n  useLayoutEffect(() => {\n    if (!mode) return;\n    if (mode === 'redraw' || paintedRef.current) { requestRedraw(); return; }\n    paintedRef.current = paintNow();\n    if (!paintedRef.current) requestRedraw();\n  });\n  // The renderer is freed on unmount; a remount (StrictMode) paints its first\n  // frame in place again.\n  useEffect(() => () => { paintedRef.current = false; }, []);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAuCA,SAAgB,iBACd,OACA,UAAgC,CAAC,GAClB;CACf,MAAM,QAAQ,kBAAkB;CAChC,MAAM,OAAO,mBAAmB,MAAM,KAAK,GAAG,OAAO;CACrD,MAAM,EAAE,kBAAkB;CAC1B,mBAAmB,OAAO,aAAa;CACvC,yBAAyB,eAAe,QAAQ,GAAG;CACnD,qBAAqB,aAAa;CAClC,wBAAwB,QAAQ,SAAS,aAAa;CACtD,YAAY,QAAQ,UAAU,aAAa;CAC3C,kBAAkB,QAAQ,gBAAgB,MAAM,KAAK,GAAG,aAAa;CACrE,OAAO;EAAE,GAAG;EAAM;CAAM;AAC1B;AAEA,SAAS,kBACP,MACA,UACA,eACM;CACN,MAAM,aAAa,OAAO,KAAK;CAE/B,sBAAsB;EACpB,IAAI,CAAC,MAAM;EACX,IAAI,SAAS,YAAY,WAAW,SAAS;GAAE,cAAc;GAAG;EAAQ;EACxE,WAAW,UAAU,SAAS;EAC9B,IAAI,CAAC,WAAW,SAAS,cAAc;CACzC,CAAC;CAGD,sBAAsB;EAAE,WAAW,UAAU;CAAO,GAAG,CAAC,CAAC;AAC3D"}