@weasel-js/core 1.9.4 → 1.10.0

package/dist/features/chrome-caps/conditions.js.map

@@ -1 +1 @@
-{"version":3,"file":"conditions.js","names":["cond","condition","evaluate","rule","ctx","combineAll","asRule","other","combineAny","value","left","a","right","b","when","fn","and","cs","or","not","c","always","ALWAYS","never","NEVER","focused","gesturing","actionIs","kind","selectionEmpty","selectionIs","n","selectionAtLeast","multiActive","hovering","hoveringSelected","modifierHeld","m","zoomAtLeast","z","modeIs","modeIn","modes","modeNot","capabilityIs","cap","capabilityIn","caps","capabilityAll","capabilityNot","coarsePointer","canHover"],"sources":["../../../src/features/chrome-caps/conditions.ts"],"sourcesContent":["import type { Condition } from './types';\nimport type { Rule } from '@weasel-js/routing';\nimport type { RuleCtx } from '@weasel-js/routing';\nimport { evaluate, ALWAYS, NEVER } from '@weasel-js/routing';\nimport type { ModifierState } from '../../interactions/gestures/types';\n\n/**\n * Promote a Rule tree to a fluent Condition. The function form evaluates\n * the tree against a RuleCtx; combinator methods produce new Conditions\n * wrapping `all`/`any`/`not` nodes.\n *\n * **Chain semantics: strict left-to-right.** No boolean precedence.\n * `focused.or(hovering).and(selectionIs(1))` evaluates\n * `((focused || hovering) && selectionIs(1))` — NOT\n * `(focused || (hovering && selectionIs(1)))` as standard precedence\n * would give. For grouped disjunction, use the top-level `or` / `and` /\n * `not` helpers or name intermediates.\n *\n * Combinators flatten same-kind nesting on construction so `a.and(b).and(c)`\n * produces `{ all: [a, b, c] }` rather than `{ all: [{ all: [a, b] }, c] }`.\n * Canonical form simplifies downstream introspection.\n *\n * Use {@link when} for the inline-lambda escape hatch.\n */\nexport function cond(rule: Rule): Condition {\n  const fn = (ctx: RuleCtx) => evaluate(rule, ctx);\n  const condition = fn as Condition;\n  (condition as { rule: Rule }).rule = rule;\n  condition.and    = (other) => cond(combineAll(rule, asRule(other)));\n  condition.or     = (other) => cond(combineAny(rule, asRule(other)));\n  condition.andNot = (other) => cond(combineAll(rule, { not: asRule(other) }));\n  condition.orNot  = (other) => cond(combineAny(rule, { not: asRule(other) }));\n  return condition;\n}\n\nfunction asRule(value: Condition | Rule): Rule {\n  return typeof value === 'function' ? (value as Condition).rule : value;\n}\n\nfunction combineAll(a: Rule, b: Rule): Rule {\n  const left = 'all' in a ? a.all : [a];\n  const right = 'all' in b ? b.all : [b];\n  return { all: [...left, ...right] };\n}\n\nfunction combineAny(a: Rule, b: Rule): Rule {\n  const left = 'any' in a ? a.any : [a];\n  const right = 'any' in b ? b.any : [b];\n  return { any: [...left, ...right] };\n}\n\n/** Inline-lambda escape hatch. Wraps the closure as a `when` rule node. */\nexport function when(fn: (ctx: RuleCtx) => boolean): Condition {\n  return cond({ when: fn });\n}\n\n// ─── Variadic helpers (for grouped expressions) ─────────────────────\n\n/** `(a && b && c && ...)` — useful when chain mixing makes left-to-right\n *  semantics ambiguous. */\nexport function and(...cs: (Condition | Rule)[]): Condition {\n  return cond({ all: cs.map(asRule) });\n}\n\n/** `(a || b || c || ...)` — preferred over `.or` chains when mixed with\n *  `.and` to make grouping explicit. */\nexport function or(...cs: (Condition | Rule)[]): Condition {\n  return cond({ any: cs.map(asRule) });\n}\n\n/** `!c` — top-level negation. Most rules use `.andNot()` / `.orNot()`\n *  instead; this is for the lead-with-negation case. */\nexport function not(c: Condition | Rule): Condition {\n  return cond({ not: asRule(c) });\n}\n\n// ─── Constant atoms ─────────────────────────────────────────────────\n\n/** Always true. The fallback for any chrome id without a registered rule. */\nexport const always: Condition = cond(ALWAYS);\n\n/** Always false. Useful for \"turn this chrome off entirely\":\n *  `chromeVisibility={{ 'snap.guides': never }}`. */\nexport const never: Condition = cond(NEVER);\n\n// ─── Focus / action atoms ───────────────────────────────────────────\n\n/** Canvas surface currently focused. */\nexport const focused: Condition = cond({ focused: true });\n\n/** Any action currently in flight (read: user is gesturing). */\nexport const gesturing: Condition = cond({ gesturing: true });\n\n/** A path is currently in anchor-edit mode. */\nexport const editingAnchors: Condition = cond({ editingAnchors: true });\n\n/** Current selection is resizable (every selected node passes the consumer's\n *  `selectTool.resize.resizable` predicate). Absent predicate → resizable. */\nexport const resizable: Condition = cond({ resizable: true });\n\n/** Active action's kind matches `kind` (e.g. `actionIs('move')`). */\nexport const actionIs = (kind: string): Condition => cond({ actionIs: kind });\n\n// ─── Selection atoms ────────────────────────────────────────────────\n\n/** Nothing selected. */\nexport const selectionEmpty: Condition = cond({ selection: { empty: true } });\n\n/** Exactly `n` items selected. */\nexport const selectionIs = (n: number): Condition => cond({ selection: { is: n } });\n\n/** At least `n` items selected. `selectionAtLeast(1)` is the common\n *  \"something is selected\" check. */\nexport const selectionAtLeast = (n: number): Condition => cond({ selection: { atLeast: n } });\n\n/** Multi-mode handle behavior active (single shared union-bounds\n *  handle vs per-item handles). Implemented as a `when` because\n *  `multiActive` is a derived single-call read on RuleCtx, not a\n *  selector-table key. Stable; safe to introspect. */\nexport const multiActive: Condition = cond({ when: (c) => c.multiActive });\n\n// ─── Hover atoms ────────────────────────────────────────────────────\n\n/** Pointer is hovering some node. */\nexport const hovering: Condition = cond({ hovering: true });\n\n/** Pointer is hovering a node that is currently selected. */\nexport const hoveringSelected: Condition = cond({ hoveringSelected: true });\n\n// ─── Modifier atoms ─────────────────────────────────────────────────\n\n/** Named modifier key currently held. */\nexport const modifierHeld = (m: keyof ModifierState): Condition => cond({ modifierHeld: m });\n\n// ─── View atoms ─────────────────────────────────────────────────────\n\n/** View scale (uniform or geometric mean for non-uniform) is at least\n *  `z`. Useful for \"hide hairline chrome at low zoom\" rules. */\nexport const zoomAtLeast = (z: number): Condition => cond({ zoomAtLeast: z });\n\n// ─── Mode + capability atoms (new) ─────────────────────────────────\n\n/** Active mode equals `m`. */\nexport const modeIs = (m: string): Condition => cond({ mode: m });\n\n/** Active mode is one of `modes`. */\nexport const modeIn = (modes: readonly string[]): Condition => cond({ mode: { in: modes } });\n\n/** Active mode is NOT `m`. */\nexport const modeNot = (m: string): Condition => cond({ mode: { not: m } });\n\n/** Active mode's `allows` includes capability `cap`. */\nexport const capabilityIs = (cap: string): Condition => cond({ capability: cap });\n\n/** Active mode's `allows` includes ANY of `caps` (OR). */\nexport const capabilityIn = (caps: readonly string[]): Condition => cond({ capability: { in: caps } });\n\n/** Active mode's `allows` includes ALL of `caps` (AND). */\nexport const capabilityAll = (caps: readonly string[]): Condition => cond({ capability: [...caps] });\n\n/** Active mode's `allows` does NOT include capability `cap`. */\nexport const capabilityNot = (cap: string): Condition => cond({ capability: { not: cap } });\n\n// ─── Device atoms ───────────────────────────────────────────────────\n\n/** Primary pointer is imprecise (touch, most styluses). Absent device\n *  profile → false, so a rule written with this atom is inert on the\n *  mouse-shaped default rather than silently flipping. */\nexport const coarsePointer: Condition = cond({ coarsePointer: true });\n\n/** Primary pointer can hover. Absent device profile → true. Pair with\n *  `not(...)` to gate chrome that only makes sense with a hovering\n *  pointer: `not(canHover)` is \"this device cannot hover\". */\nexport const canHover: Condition = cond({ canHover: true });\n"],"mappings":"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"}
+{"version":3,"file":"conditions.js","names":["cond","condition","evaluate","rule","ctx","combineAll","asRule","other","combineAny","value","left","a","right","b","when","fn","and","cs","or","not","c","always","ALWAYS","never","NEVER","focused","gesturing","actionIs","kind","selectionEmpty","selectionIs","n","selectionAtLeast","multiActive","hovering","hoveringSelected","modifierHeld","m","zoomAtLeast","z","modeIs","modeIn","modes","modeNot","capabilityIs","cap","capabilityIn","caps","capabilityAll","capabilityNot","coarsePointer","canHover"],"sources":["../../../src/features/chrome-caps/conditions.ts"],"sourcesContent":["import type { Condition } from './types';\nimport type { Rule } from '@weasel-js/routing';\nimport type { RuleCtx } from '@weasel-js/routing';\nimport { evaluate, ALWAYS, NEVER } from '@weasel-js/routing';\nimport type { ModifierState } from '../../interactions/gestures/types';\n\n/**\n * Promote a Rule tree to a fluent Condition.\n *\n * **Chain semantics: strict left-to-right.** No boolean precedence.\n * `focused.or(hovering).and(selectionIs(1))` evaluates\n * `((focused || hovering) && selectionIs(1))`. For grouped disjunction, use\n * the top-level `or` / `and` / `not` helpers or name intermediates.\n *\n * Combinators flatten same-kind nesting on construction so `a.and(b).and(c)`\n * produces `{ all: [a, b, c] }`.\n */\nexport function cond(rule: Rule): Condition {\n  const fn = (ctx: RuleCtx) => evaluate(rule, ctx);\n  const condition = fn as Condition;\n  (condition as { rule: Rule }).rule = rule;\n  condition.and    = (other) => cond(combineAll(rule, asRule(other)));\n  condition.or     = (other) => cond(combineAny(rule, asRule(other)));\n  condition.andNot = (other) => cond(combineAll(rule, { not: asRule(other) }));\n  condition.orNot  = (other) => cond(combineAny(rule, { not: asRule(other) }));\n  return condition;\n}\n\nfunction asRule(value: Condition | Rule): Rule {\n  return typeof value === 'function' ? (value as Condition).rule : value;\n}\n\nfunction combineAll(a: Rule, b: Rule): Rule {\n  const left = 'all' in a ? a.all : [a];\n  const right = 'all' in b ? b.all : [b];\n  return { all: [...left, ...right] };\n}\n\nfunction combineAny(a: Rule, b: Rule): Rule {\n  const left = 'any' in a ? a.any : [a];\n  const right = 'any' in b ? b.any : [b];\n  return { any: [...left, ...right] };\n}\n\n/** Inline-lambda escape hatch. Wraps the closure as a `when` rule node. */\nexport function when(fn: (ctx: RuleCtx) => boolean): Condition {\n  return cond({ when: fn });\n}\n\n// ─── Variadic helpers (for grouped expressions) ─────────────────────\n\n/** `(a && b && c && ...)` — useful when chain mixing makes left-to-right\n *  semantics ambiguous. */\nexport function and(...cs: (Condition | Rule)[]): Condition {\n  return cond({ all: cs.map(asRule) });\n}\n\n/** `(a || b || c || ...)` — preferred over `.or` chains when mixed with\n *  `.and` to make grouping explicit. */\nexport function or(...cs: (Condition | Rule)[]): Condition {\n  return cond({ any: cs.map(asRule) });\n}\n\n/** `!c` — top-level negation. Most rules use `.andNot()` / `.orNot()`\n *  instead; this is for the lead-with-negation case. */\nexport function not(c: Condition | Rule): Condition {\n  return cond({ not: asRule(c) });\n}\n\n// ─── Constant atoms ─────────────────────────────────────────────────\n\n/** Always true. The fallback for any chrome id without a registered rule. */\nexport const always: Condition = cond(ALWAYS);\n\n/** Always false. Useful for \"turn this chrome off entirely\":\n *  `chromeVisibility={{ 'snap.guides': never }}`. */\nexport const never: Condition = cond(NEVER);\n\n// ─── Focus / action atoms ───────────────────────────────────────────\n\n/** Canvas surface currently focused. */\nexport const focused: Condition = cond({ focused: true });\n\n/** Any action currently in flight (read: user is gesturing). */\nexport const gesturing: Condition = cond({ gesturing: true });\n\n/** A path is currently in anchor-edit mode. */\nexport const editingAnchors: Condition = cond({ editingAnchors: true });\n\n/** Current selection is resizable (every selected node passes the consumer's\n *  `selectTool.resize.resizable` predicate). Absent predicate → resizable. */\nexport const resizable: Condition = cond({ resizable: true });\n\n/** Active action's kind matches `kind` (e.g. `actionIs('move')`). */\nexport const actionIs = (kind: string): Condition => cond({ actionIs: kind });\n\n// ─── Selection atoms ────────────────────────────────────────────────\n\n/** Nothing selected. */\nexport const selectionEmpty: Condition = cond({ selection: { empty: true } });\n\n/** Exactly `n` items selected. */\nexport const selectionIs = (n: number): Condition => cond({ selection: { is: n } });\n\n/** At least `n` items selected. `selectionAtLeast(1)` is the common\n *  \"something is selected\" check. */\nexport const selectionAtLeast = (n: number): Condition => cond({ selection: { atLeast: n } });\n\n/** Multi-mode handle behavior active (single shared union-bounds\n *  handle vs per-item handles). */\nexport const multiActive: Condition = cond({ when: (c) => c.multiActive });\n\n// ─── Hover atoms ────────────────────────────────────────────────────\n\n/** Pointer is hovering some node. */\nexport const hovering: Condition = cond({ hovering: true });\n\n/** Pointer is hovering a node that is currently selected. */\nexport const hoveringSelected: Condition = cond({ hoveringSelected: true });\n\n// ─── Modifier atoms ─────────────────────────────────────────────────\n\n/** Named modifier key currently held. */\nexport const modifierHeld = (m: keyof ModifierState): Condition => cond({ modifierHeld: m });\n\n// ─── View atoms ─────────────────────────────────────────────────────\n\n/** View scale (uniform or geometric mean for non-uniform) is at least\n *  `z`. Useful for \"hide hairline chrome at low zoom\" rules. */\nexport const zoomAtLeast = (z: number): Condition => cond({ zoomAtLeast: z });\n\n// ─── Mode + capability atoms ───────────────────────────────────────\n\n/** Active mode equals `m`. */\nexport const modeIs = (m: string): Condition => cond({ mode: m });\n\n/** Active mode is one of `modes`. */\nexport const modeIn = (modes: readonly string[]): Condition => cond({ mode: { in: modes } });\n\n/** Active mode is NOT `m`. */\nexport const modeNot = (m: string): Condition => cond({ mode: { not: m } });\n\n/** Active mode's `allows` includes capability `cap`. */\nexport const capabilityIs = (cap: string): Condition => cond({ capability: cap });\n\n/** Active mode's `allows` includes ANY of `caps` (OR). */\nexport const capabilityIn = (caps: readonly string[]): Condition => cond({ capability: { in: caps } });\n\n/** Active mode's `allows` includes ALL of `caps` (AND). */\nexport const capabilityAll = (caps: readonly string[]): Condition => cond({ capability: [...caps] });\n\n/** Active mode's `allows` does NOT include capability `cap`. */\nexport const capabilityNot = (cap: string): Condition => cond({ capability: { not: cap } });\n\n// ─── Device atoms ───────────────────────────────────────────────────\n\n/** Primary pointer is imprecise (touch, most styluses). Absent device\n *  profile → false. */\nexport const coarsePointer: Condition = cond({ coarsePointer: true });\n\n/** Primary pointer can hover. Absent device profile → true. */\nexport const canHover: Condition = cond({ canHover: true });\n"],"mappings":"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"}

package/dist/features/chrome-caps/defaults.js.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.js","names":["defaultVisibilityRules"],"sources":["../../../src/features/chrome-caps/defaults.ts"],"sourcesContent":["import type { VisibilityRules } from './types';\nimport type { Rule } from '@weasel-js/routing';\n\n/**\n * Kit-shipped defaults. Merged with the consumer's `chromeVisibility` map\n * at resolve time; consumer entries take precedence per id.\n *\n * Written as literal Rule trees rather than fluent chains so the inputs\n * each rule depends on are immediately visible. The fluent atoms compile\n * to the same trees; either form is valid in a VisibilityRules entry.\n *\n * Gating is written in terms of **capabilities, not mode ids**. A\n * capability rule keeps holding when a new mode is added that permits the\n * same thing; a mode rule has to be found and edited every time. There is\n * no `mode:` rule left in this table — the `path-edit.*` chrome used to be\n * the exception, on the theory that it's the visual signature of one mode;\n * see the comment on those rules below for why that was wrong in both\n * directions and what replaced it.\n *\n * Chrome that gates on the *absence* of a capability (the selection\n * outline, suppressed while an anchor-editing overlay owns the visuals)\n * uses `capability: { not: … }` for the same reason.\n */\nexport const defaultVisibilityRules: VisibilityRules = {\n  // Static selection chrome — visible while a selection exists, but off\n  // whenever an anchor-editing overlay has taken over the visuals (today:\n  // path-edit mode; tomorrow: anything else that allows `edits-anchors`).\n  'selection.outline': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { capability: { not: 'edits-anchors' } },\n    ],\n  } as Rule,\n\n  // Handles hide during an action so the moving / resizing object isn't\n  // visually crowded; they reappear on commit. Gated on the mode actually\n  // permitting transforms — grabbing a resize handle in a mode that\n  // forbids `transforms-selection` could only ever be a no-op — and on the\n  // selection being resizable (consumer `resizable` predicate).\n  'selection.resize-handles': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { not: { gesturing: true } },\n      { capability: 'transforms-selection' },\n      { resizable: true },\n    ],\n  } as Rule,\n\n  // Rotation handle visible whenever any selection is focused — single\n  // mode pivots around the selected node's center; multi mode pivots\n  // around the union AABB center. Same transform gating as resize; also\n  // off during an action.\n  'selection.rotation-handle': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { focused: true },\n      { not: { gesturing: true } },\n      { capability: 'transforms-selection' },\n    ],\n  } as Rule,\n\n  // Transient action chrome — only shown during the matching action.\n  'action.marquee':     { actionIs: 'marquee' } as Rule,\n  'action.lasso':       { actionIs: 'lasso' } as Rule,\n  'action.move-ghosts': { actionIs: 'move' } as Rule,\n\n  // Path-edit chrome — gated on there actually being an edited path.\n  //\n  // This used to read `{ mode: 'path-edit' }`, which was wrong in both\n  // directions. Consumers with no mode registry report mode `'normal'`,\n  // so the anchor hit-test (which asks `isVisible('path-edit.anchors')`)\n  // refused every anchor while the overlay — which never consulted the\n  // table at all — drew them anyway: visible but not grabbable, the exact\n  // failure this table exists to make impossible. And a consumer defining\n  // its own anchor-editing mode under a different id got neither.\n  //\n  // `editingAnchors` is the state both surfaces actually care about. It's\n  // a state selector rather than a `capability:` one on purpose: the\n  // capability says the user *may* edit anchors, which is not the same as\n  // a path *being* edited, and drawing anchors for the former is wrong.\n  'path-edit.anchors': { editingAnchors: true } as Rule,\n  'path-edit.overlay': { editingAnchors: true } as Rule,\n\n  // Snap system — guides during any action; targets consumer-driven for now.\n  'snap.guides': { gesturing: true } as Rule,\n  // 'snap.targets' — no default; consumer-driven for now.\n\n  // 'grid' / 'debug.*' — no default; visibility currently driven by\n  // dedicated boolean props on <SceneCanvas>. They'll move into this\n  // table as they migrate.\n};\n"],"mappings":";AAuBA,IAAaA,IAA0C;CAIrD,qBAAqB,EACnB,KAAK,CACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE,GAC5B,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,CACzC,EACF;CAOA,4BAA4B,EAC1B,KAAK;EACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;EAC5B,EAAE,KAAK,EAAE,WAAW,GAAK,EAAE;EAC3B,EAAE,YAAY,uBAAuB;EACrC,EAAE,WAAW,GAAK;CACpB,EACF;CAMA,6BAA6B,EAC3B,KAAK;EACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;EAC5B,EAAE,SAAS,GAAK;EAChB,EAAE,KAAK,EAAE,WAAW,GAAK,EAAE;EAC3B,EAAE,YAAY,uBAAuB;CACvC,EACF;CAGA,kBAAsB,EAAE,UAAU,UAAU;CAC5C,gBAAsB,EAAE,UAAU,QAAQ;CAC1C,sBAAsB,EAAE,UAAU,OAAO;CAgBzC,qBAAqB,EAAE,gBAAgB,GAAK;CAC5C,qBAAqB,EAAE,gBAAgB,GAAK;CAG5C,eAAe,EAAE,WAAW,GAAK;AAMnC"}
+{"version":3,"file":"defaults.js","names":["defaultVisibilityRules"],"sources":["../../../src/features/chrome-caps/defaults.ts"],"sourcesContent":["import type { VisibilityRules } from './types';\nimport type { Rule } from '@weasel-js/routing';\n\n/**\n * Kit-shipped defaults. Merged with the consumer's `chromeVisibility` map\n * at resolve time; consumer entries take precedence per id.\n *\n * Gating is written in terms of **capabilities, not mode ids**. A\n * capability rule keeps holding when a new mode is added that permits the\n * same thing; a mode rule has to be found and edited every time.\n */\nexport const defaultVisibilityRules: VisibilityRules = {\n  // Off whenever an anchor-editing overlay has taken over the visuals.\n  'selection.outline': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { capability: { not: 'edits-anchors' } },\n    ],\n  } as Rule,\n\n  // Handles hide during an action so the moving / resizing object isn't\n  // visually crowded; they reappear on commit.\n  'selection.resize-handles': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { not: { gesturing: true } },\n      { capability: 'transforms-selection' },\n      { resizable: true },\n    ],\n  } as Rule,\n\n  'selection.rotation-handle': {\n    all: [\n      { selection: { atLeast: 1 } },\n      { focused: true },\n      { not: { gesturing: true } },\n      { capability: 'transforms-selection' },\n    ],\n  } as Rule,\n\n  // Transient action chrome — only shown during the matching action.\n  'action.marquee':     { actionIs: 'marquee' } as Rule,\n  'action.lasso':       { actionIs: 'lasso' } as Rule,\n  'action.move-ghosts': { actionIs: 'move' } as Rule,\n\n  // Path-edit chrome — gated on there actually being an edited path, not on\n  // `{ mode: 'path-edit' }`: consumers with no mode registry report mode\n  // `'normal'`, and one defining its own anchor-editing mode uses another id.\n  // A state selector rather than a `capability:` one on purpose: the\n  // capability says the user *may* edit anchors, which is not the same as\n  // a path *being* edited.\n  'path-edit.anchors': { editingAnchors: true } as Rule,\n  'path-edit.overlay': { editingAnchors: true } as Rule,\n\n  // Snap system — guides during any action; targets consumer-driven for now.\n  'snap.guides': { gesturing: true } as Rule,\n  // 'snap.targets' — no default; consumer-driven for now.\n\n  // 'grid' / 'debug.*' — no default; visibility is driven by dedicated\n  // boolean props on <SceneCanvas>.\n};\n"],"mappings":";AAWA,IAAaA,IAA0C;CAErD,qBAAqB,EACnB,KAAK,CACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE,GAC5B,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,CACzC,EACF;CAIA,4BAA4B,EAC1B,KAAK;EACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;EAC5B,EAAE,KAAK,EAAE,WAAW,GAAK,EAAE;EAC3B,EAAE,YAAY,uBAAuB;EACrC,EAAE,WAAW,GAAK;CACpB,EACF;CAEA,6BAA6B,EAC3B,KAAK;EACH,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;EAC5B,EAAE,SAAS,GAAK;EAChB,EAAE,KAAK,EAAE,WAAW,GAAK,EAAE;EAC3B,EAAE,YAAY,uBAAuB;CACvC,EACF;CAGA,kBAAsB,EAAE,UAAU,UAAU;CAC5C,gBAAsB,EAAE,UAAU,QAAQ;CAC1C,sBAAsB,EAAE,UAAU,OAAO;CAQzC,qBAAqB,EAAE,gBAAgB,GAAK;CAC5C,qBAAqB,EAAE,gBAAgB,GAAK;CAG5C,eAAe,EAAE,WAAW,GAAK;AAKnC"}

package/dist/features/chrome-caps/resolve.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolve.js","names":["resolveVisibility","merged","consumer","defaultVisibilityRules","ruleCtx","ctx","viewZoom","DEFAULT_ALLOWED_CAPABILITIES","entry","id","evaluate"],"sources":["../../../src/features/chrome-caps/resolve.ts"],"sourcesContent":["import type { ChromeCtx, ChromeId, VisibilityRules } from './types';\nimport type { RuleCtx } from '@weasel-js/routing';\nimport { DEFAULT_ALLOWED_CAPABILITIES } from '@weasel-js/routing';\nimport { evaluate } from '@weasel-js/routing';\nimport { defaultVisibilityRules } from './defaults';\nimport { viewZoom } from 'core/viewport/view';\n\n/**\n * Build the per-frame visibility check. Merges consumer rules on top\n * of the kit defaults, then closes over `ctx` so each chrome-id\n * lookup runs its rule against the current state.\n *\n * `VisibilityRules` entries may be either fluent `Condition` values\n * (callable) or raw `Rule` trees — we normalize at lookup time.\n *\n * Predicates are O(1) and run once per chrome id per frame; no\n * memoization in v1 — profile before adding any.\n *\n * `ChromeCtx` is the legacy shape; surfaces still on it get `mode='normal'`\n * and `DEFAULT_ALLOWED_CAPABILITIES` filled in here, so a caller that never\n * opted into modality behaves exactly like one sitting in normal mode.\n */\nexport function resolveVisibility(\n  consumer: VisibilityRules | undefined,\n  ctx: ChromeCtx | RuleCtx,\n): (id: ChromeId) => boolean {\n  const merged: VisibilityRules = consumer\n    ? { ...defaultVisibilityRules, ...consumer }\n    : defaultVisibilityRules;\n  const ruleCtx: RuleCtx = 'mode' in ctx\n    ? ctx\n    : {\n      ...ctx,\n      zoom: viewZoom(ctx.view),\n      mode: 'normal',\n      allowedCapabilities: DEFAULT_ALLOWED_CAPABILITIES,\n    };\n  return (id) => {\n    const entry = merged[id];\n    if (entry === undefined) return true;\n    if (typeof entry === 'function') return entry(ruleCtx);\n    return evaluate(entry, ruleCtx);\n  };\n}\n"],"mappings":";;;;AAsBA,SAAgBA,EACd,GACA,GAC2B;CAC3B,IAAMC,IAA0BC,IAC5B;EAAE,GAAGC;EAAwB,GAAGD;CAAS,IACzCC,GACEC,IAAmB,UAAUC,IAC/BA,IACA;EACA,GAAGA;EACH,MAAMC,EAASD,EAAI,IAAI;EACvB,MAAM;EACN,qBAAqBE;CACvB;CACF,QAAQ,MAAO;EACb,IAAMC,IAAQP,EAAOQ;EAGrB,OAFID,MAAU,KAAA,IAAkB,KAC5B,OAAOA,KAAU,aAAmBA,EAAMJ,CAAO,IAC9CM,EAASF,GAAOJ,CAAO;CAChC;AACF"}
+{"version":3,"file":"resolve.js","names":["resolveVisibility","merged","consumer","defaultVisibilityRules","ruleCtx","ctx","viewZoom","DEFAULT_ALLOWED_CAPABILITIES","entry","id","evaluate"],"sources":["../../../src/features/chrome-caps/resolve.ts"],"sourcesContent":["import type { ChromeCtx, ChromeId, VisibilityRules } from './types';\nimport type { RuleCtx } from '@weasel-js/routing';\nimport { DEFAULT_ALLOWED_CAPABILITIES } from '@weasel-js/routing';\nimport { evaluate } from '@weasel-js/routing';\nimport { defaultVisibilityRules } from './defaults';\nimport { viewZoom } from 'core/viewport/view';\n\n/**\n * Build the per-frame visibility check: consumer rules merged on top of\n * the kit defaults, evaluated against `ctx`.\n *\n * `ChromeCtx` is the legacy shape; surfaces still on it get `mode='normal'`\n * and `DEFAULT_ALLOWED_CAPABILITIES` filled in here, so a caller that never\n * opted into modality behaves exactly like one sitting in normal mode.\n */\nexport function resolveVisibility(\n  consumer: VisibilityRules | undefined,\n  ctx: ChromeCtx | RuleCtx,\n): (id: ChromeId) => boolean {\n  const merged: VisibilityRules = consumer\n    ? { ...defaultVisibilityRules, ...consumer }\n    : defaultVisibilityRules;\n  const ruleCtx: RuleCtx = 'mode' in ctx\n    ? ctx\n    : {\n      ...ctx,\n      zoom: viewZoom(ctx.view),\n      mode: 'normal',\n      allowedCapabilities: DEFAULT_ALLOWED_CAPABILITIES,\n    };\n  return (id) => {\n    const entry = merged[id];\n    if (entry === undefined) return true;\n    if (typeof entry === 'function') return entry(ruleCtx);\n    return evaluate(entry, ruleCtx);\n  };\n}\n"],"mappings":";;;;AAeA,SAAgBA,EACd,GACA,GAC2B;CAC3B,IAAMC,IAA0BC,IAC5B;EAAE,GAAGC;EAAwB,GAAGD;CAAS,IACzCC,GACEC,IAAmB,UAAUC,IAC/BA,IACA;EACA,GAAGA;EACH,MAAMC,EAASD,EAAI,IAAI;EACvB,MAAM;EACN,qBAAqBE;CACvB;CACF,QAAQ,MAAO;EACb,IAAMC,IAAQP,EAAOQ;EAGrB,OAFID,MAAU,KAAA,IAAkB,KAC5B,OAAOA,KAAU,aAAmBA,EAAMJ,CAAO,IAC9CM,EAASF,GAAOJ,CAAO;CAChC;AACF"}

package/dist/features/chrome-caps/useChromeCaps.js

@@ -0,0 +1,54 @@
+import { viewZoom as e } from "../../core/viewport/view.js";
+import { resolveVisibility as t } from "./resolve.js";
+import { useMemo as n } from "react";
+import { useLatest as r } from "@weasel-js/react";
+import { DEFAULT_ALLOWED_CAPABILITIES as i, buildRuleCtx as a } from "@weasel-js/routing";
+//#region src/features/chrome-caps/useChromeCaps.ts
+var o = {
+	alt: !1,
+	ctrl: !1,
+	meta: !1,
+	shift: !1
+};
+function s(t, n) {
+	let { resizable: r } = t;
+	return a({
+		focused: t.focused,
+		selection: n.selection,
+		multiActive: n.selection.length > 1,
+		modifiers: t.modifiers ?? o,
+		action: n.action,
+		hover: t.hover,
+		zoom: e(n.view),
+		mode: t.mode?.id ?? "normal",
+		allowedCapabilities: t.mode?.allowedCapabilities ?? i,
+		selectionResizable: r ? n.selection.every((e) => r(e)) : void 0,
+		editingAnchors: t.editingAnchors,
+		device: t.device
+	});
+}
+function c(e) {
+	let i = r(e);
+	return n(() => {
+		let e = (e) => {
+			let t = i.current;
+			return s({
+				focused: !t.getFocused || t.getFocused(),
+				modifiers: t.getModifiers?.(),
+				hover: t.getHover(),
+				mode: t.getMode?.(),
+				resizable: t.resizable,
+				editingAnchors: t.editingAnchors(),
+				device: t.device
+			}, e);
+		};
+		return {
+			ruleCtx: (t) => i.current.getMode ? e(t) : void 0,
+			isVisible: (n) => t(i.current.rules, e(n))
+		};
+	}, [i]);
+}
+//#endregion
+export { s as surfaceRuleCtx, c as useChromeCaps };
+
+//# sourceMappingURL=useChromeCaps.js.map

package/dist/features/chrome-caps/useChromeCaps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChromeCaps.js","names":["NO_MODIFIERS","surfaceRuleCtx","surface","buildRuleCtx","view","viewZoom","DEFAULT_ALLOWED_CAPABILITIES","resizable","id","useChromeCaps","live","useLatest","source","useMemo","build","now","inputs","resolveVisibility"],"sources":["../../../src/features/chrome-caps/useChromeCaps.ts"],"sourcesContent":["/**\n * The rule context a surface's chrome-visibility rules and action eligibility\n * are evaluated against, and the hook that keeps one for `<SceneCanvas>`.\n */\nimport { useMemo } from 'react';\nimport type { ActiveMode } from '@weasel-js/modes';\nimport { useLatest } from '@weasel-js/react';\nimport {\n  buildRuleCtx,\n  DEFAULT_ALLOWED_CAPABILITIES,\n  type DeviceProfile,\n  type ModifierState,\n  type RuleCtx,\n} from '@weasel-js/routing';\nimport type { NodeId } from '../../core/scene/types';\nimport { viewZoom, type View } from '../../core/viewport/view';\nimport { resolveVisibility } from './resolve';\nimport type { VisibilityRules } from './types';\n\n/**\n * The part of a rule context that belongs to one view. Everything else a\n * `RuleCtx` carries — mode, capabilities, device, focus — is the surface's and\n * the same for every view drawn on it.\n */\nexport interface ViewRuleInputs {\n  selection: readonly NodeId[];\n  view: View;\n  /** What that view's dispatcher currently has in flight. */\n  action: { kind: string | null; id: string | null };\n}\n\n/** The part of a rule context that belongs to the surface. */\nexport interface SurfaceRuleInputs {\n  focused: boolean;\n  /** The modifier keys held. Absent means none, so `modifierHeld` never matches. */\n  modifiers?: ModifierState | undefined;\n  hover: NodeId | null;\n  /** Absent on a surface with no mode registry, which behaves as normal mode. */\n  mode: ActiveMode | undefined;\n  /** Whether one node may be resized. Absent means every node may. */\n  resizable: ((id: string) => boolean) | undefined;\n  editingAnchors: boolean;\n  device: DeviceProfile;\n}\n\nconst NO_MODIFIERS = { alt: false, ctrl: false, meta: false, shift: false };\n\n/** One view's rule context on a surface. */\nexport function surfaceRuleCtx(surface: SurfaceRuleInputs, view: ViewRuleInputs): RuleCtx {\n  const { resizable } = surface;\n  return buildRuleCtx({\n    focused: surface.focused,\n    selection: view.selection,\n    multiActive: view.selection.length > 1,\n    modifiers: surface.modifiers ?? NO_MODIFIERS,\n    action: view.action,\n    hover: surface.hover,\n    zoom: viewZoom(view.view),\n    mode: surface.mode?.id ?? 'normal',\n    // An empty set would make every `capability:` rule false and hide the\n    // chrome those rules gate.\n    allowedCapabilities: surface.mode?.allowedCapabilities ?? DEFAULT_ALLOWED_CAPABILITIES,\n    // Left undefined without a predicate, which `resizable:` reads as resizable.\n    selectionResizable: resizable ? view.selection.every((id) => resizable(id)) : undefined,\n    editingAnchors: surface.editingAnchors,\n    device: surface.device,\n  });\n}\n\n/** Where a surface's rule context comes from. Read at the moment a rule is\n *  evaluated, never at render. */\nexport interface ChromeCapsSource {\n  /** The surface's rule table, over the kit defaults. */\n  rules: VisibilityRules | undefined;\n  /** The active mode. Absent when no mode registry is wired. */\n  getMode: (() => ActiveMode) | undefined;\n  /** Absent means the surface always counts as focused. */\n  getFocused: (() => boolean) | undefined;\n  getHover: () => NodeId | null;\n  /** Absent means no modifier key ever counts as held. */\n  getModifiers?: (() => ModifierState) | undefined;\n  resizable: ((id: string) => boolean) | undefined;\n  editingAnchors: () => boolean;\n  device: DeviceProfile;\n}\n\n/**\n * A surface's chrome-caps answers for one view. The rules are surface-wide on\n * purpose — one consumer table, one set of kit defaults — but a rule keyed on\n * selection, camera or the in-flight action answers differently per view, so\n * the caller supplies that part and both the paint gate and the dispatcher's\n * eligibility filter read the same context.\n */\nexport interface ChromeCaps {\n  /** `undefined` when the surface gates nothing: no mode registry is wired. */\n  ruleCtx(inputs: ViewRuleInputs): RuleCtx | undefined;\n  isVisible(inputs: ViewRuleInputs): (id: string) => boolean;\n}\n\n/** The chrome-caps answers for a surface. The object keeps its identity for\n *  the life of the component and reads `source` as of the last commit. */\nexport function useChromeCaps(source: ChromeCapsSource): ChromeCaps {\n  const live = useLatest(source);\n  return useMemo(() => {\n    const build = (inputs: ViewRuleInputs): RuleCtx => {\n      const now = live.current;\n      return surfaceRuleCtx({\n        focused: now.getFocused ? now.getFocused() : true,\n        modifiers: now.getModifiers?.(),\n        hover: now.getHover(),\n        mode: now.getMode?.(),\n        resizable: now.resizable,\n        editingAnchors: now.editingAnchors(),\n        device: now.device,\n      }, inputs);\n    };\n    return {\n      ruleCtx: (inputs) => (live.current.getMode ? build(inputs) : undefined),\n      isVisible: (inputs) => resolveVisibility(live.current.rules, build(inputs)),\n    };\n  }, [live]);\n}\n"],"mappings":";;;;;;AA6CA,IAAMA,IAAe;CAAE,KAAK;CAAO,MAAM;CAAO,MAAM;CAAO,OAAO;AAAM;AAG1E,SAAgBC,EAAe,GAA4B,GAA+B;CACxF,IAAM,EAAE,iBAAcC;CACtB,OAAOC,EAAa;EAClB,SAASD,EAAQ;EACjB,WAAWE,EAAK;EAChB,aAAaA,EAAK,UAAU,SAAS;EACrC,WAAWF,EAAQ,aAAaF;EAChC,QAAQI,EAAK;EACb,OAAOF,EAAQ;EACf,MAAMG,EAASD,EAAK,IAAI;EACxB,MAAMF,EAAQ,MAAM,MAAM;EAG1B,qBAAqBA,EAAQ,MAAM,uBAAuBI;EAE1D,oBAAoBC,IAAYH,EAAK,UAAU,OAAO,MAAOG,EAAUC,CAAE,CAAC,IAAI,KAAA;EAC9E,gBAAgBN,EAAQ;EACxB,QAAQA,EAAQ;CAClB,CAAC;AACH;AAkCA,SAAgBO,EAAc,GAAsC;CAClE,IAAMC,IAAOC,EAAUC,CAAM;CAC7B,OAAOC,QAAc;EACnB,IAAMC,KAAS,MAAoC;GACjD,IAAMC,IAAML,EAAK;GACjB,OAAOT,EAAe;IACpB,SAAS,GAAI,cAAac,EAAI,WAAW;IACzC,WAAWA,EAAI,eAAe;IAC9B,OAAOA,EAAI,SAAS;IACpB,MAAMA,EAAI,UAAU;IACpB,WAAWA,EAAI;IACf,gBAAgBA,EAAI,eAAe;IACnC,QAAQA,EAAI;GACd,GAAGC,CAAM;EACX;EACA,OAAO;GACL,UAAU,MAAYN,EAAK,QAAQ,UAAUI,EAAME,CAAM,IAAI,KAAA;GAC7D,YAAY,MAAWC,EAAkBP,EAAK,QAAQ,OAAOI,EAAME,CAAM,CAAC;EAC5E;CACF,GAAG,CAACN,CAAI,CAAC;AACX"}

package/dist/features/chrome-caps/useHoverTracking.js.map

@@ -1 +1 @@
-{"version":3,"file":"useHoverTracking.js","names":["useHoverTracking","args","hoverRef","useRef","nodeAtRef","useLatest","nodeAtClientPoint","elementRef","enabledRef","enabled","detachRef","sync","useCallback","el","onMove","onLeave","canvasRef","element","getHover","useMemo"],"sources":["../../../src/features/chrome-caps/useHoverTracking.ts"],"sourcesContent":["/**\n * useHoverTracking — last-hovered NodeId for chrome-caps rules.\n *\n * Listens for `pointermove` on the element handed to the returned\n * `canvasRef`; on each move it runs the supplied `nodeAtClientPoint` and\n * caches the resulting id on a ref. Cleared on `pointerleave` (pointer left\n * the canvas → nothing is hovered).\n *\n * `getHover` is a stable getter — call once per frame from `buildChromeCtx`.\n *\n * No re-render: the ref updates silently, and the next render that\n * reads it picks up the fresh value. Chrome-caps rules are evaluated\n * during paint, so the hover state is always read fresh.\n */\n\nimport { useCallback, useEffect, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeId } from '../../core/scene/types';\n\n/** Options for `useHoverTracking`. */\nexport interface UseHoverTrackingArgs {\n  /** Topmost id under a client point, or null. One lookup rather than a\n   *  client→world thunk beside a world-space picker: a screen-pixel pick\n   *  tolerance converts against the camera the point resolved to, and two\n   *  thunks are two chances to disagree about which view that is. */\n  nodeAtClientPoint: (clientX: number, clientY: number) => { id: NodeId } | null;\n  enabled?: boolean;\n}\n\n/** What `useHoverTracking` returns. Both members keep their identity. */\nexport interface HoverTracking {\n  /** The node the pointer is over, or null. */\n  getHover: () => NodeId | null;\n  /** Hand it the element to track, or null to stop: a callback ref, so an\n   *  element that mounts after the hook is tracked from the moment it arrives. */\n  canvasRef: (element: HTMLElement | null) => void;\n}\n\n/** Track which node the pointer is over. Returns a getter rather than state,\n *  so per-frame code can read the current value without the hover re-rendering\n *  the component on every pointer move. */\nexport function useHoverTracking(args: UseHoverTrackingArgs): HoverTracking {\n  const { nodeAtClientPoint, enabled = true } = args;\n  const hoverRef = useRef<NodeId | null>(null);\n  const nodeAtRef = useLatest(nodeAtClientPoint);\n  const elementRef = useRef<HTMLElement | null>(null);\n  const enabledRef = useRef(enabled);\n  const detachRef = useRef<(() => void) | null>(null);\n\n  const sync = useCallback(() => {\n    detachRef.current?.();\n    detachRef.current = null;\n    hoverRef.current = null;\n    const el = elementRef.current;\n    if (!el || !enabledRef.current) return;\n    const onMove = (e: PointerEvent) => {\n      hoverRef.current = nodeAtRef.current(e.clientX, e.clientY)?.id ?? null;\n    };\n    const onLeave = () => { hoverRef.current = null; };\n    el.addEventListener('pointermove', onMove);\n    el.addEventListener('pointerleave', onLeave);\n    detachRef.current = () => {\n      el.removeEventListener('pointermove', onMove);\n      el.removeEventListener('pointerleave', onLeave);\n    };\n  }, [nodeAtRef]);\n\n  useEffect(() => {\n    enabledRef.current = enabled;\n    sync();\n    return () => {\n      detachRef.current?.();\n      detachRef.current = null;\n      hoverRef.current = null;\n    };\n  }, [enabled, sync]);\n\n  const canvasRef = useCallback((element: HTMLElement | null) => {\n    if (elementRef.current === element) return;\n    elementRef.current = element;\n    sync();\n  }, [sync]);\n  const getHover = useCallback(() => hoverRef.current, []);\n\n  return useMemo(() => ({ getHover, canvasRef }), [getHover, canvasRef]);\n}\n"],"mappings":";;;AAyCA,SAAgBA,EAAiB,GAA2C;CAC1E,IAAM,EAAE,sBAAmB,aAAU,OAASC,GACxCC,IAAWC,EAAsB,IAAI,GACrCC,IAAYC,EAAUC,CAAiB,GACvCC,IAAaJ,EAA2B,IAAI,GAC5CK,IAAaL,EAAOM,CAAO,GAC3BC,IAAYP,EAA4B,IAAI,GAE5CQ,IAAOC,QAAkB;EAG7B,AAFAF,EAAU,UAAU,GACpB,EAAU,UAAU,MACpB,EAAS,UAAU;EACnB,IAAMG,IAAKN,EAAW;EACtB,IAAI,CAACM,KAAM,CAACL,EAAW,SAAS;EAChC,IAAMM,KAAU,MAAoB;GAClC,EAAS,UAAUV,EAAU,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM;EACpE,GACMW,UAAgB;GAAE,EAAS,UAAU;EAAM;EAGjD,AAFAF,EAAG,iBAAiB,eAAeC,CAAM,GACzCD,EAAG,iBAAiB,gBAAgBE,CAAO,GAC3C,EAAU,gBAAgB;GAExB,AADAF,EAAG,oBAAoB,eAAeC,CAAM,GAC5CD,EAAG,oBAAoB,gBAAgBE,CAAO;EAChD;CACF,GAAG,CAACX,CAAS,CAAC;CAEd,SACE,EAAW,UAAUK,GACrBE,EAAK,SACQ;EAGX,AAFAD,EAAU,UAAU,GACpB,EAAU,UAAU,MACpB,EAAS,UAAU;CACrB,IACC,CAACD,GAASE,CAAI,CAAC;CAElB,IAAMK,IAAYJ,GAAa,MAAgC;EAC7D,AAAIL,EAAW,YAAYU,MAC3B,EAAW,UAAUA,GACrBN,EAAK;CACP,GAAG,CAACA,CAAI,CAAC,GACHO,IAAWN,QAAkBV,EAAS,SAAS,CAAC,CAAC;CAEvD,OAAOiB,SAAe;EAAE;EAAU;CAAU,IAAI,CAACD,GAAUF,CAAS,CAAC;AACvE"}
+{"version":3,"file":"useHoverTracking.js","names":["useHoverTracking","args","hoverRef","useRef","nodeAtRef","useLatest","nodeAtClientPoint","elementRef","enabledRef","enabled","detachRef","sync","useCallback","el","onMove","onLeave","canvasRef","element","getHover","useMemo"],"sources":["../../../src/features/chrome-caps/useHoverTracking.ts"],"sourcesContent":["/** Last-hovered NodeId for chrome-caps rules. */\n\nimport { useCallback, useEffect, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeId } from '../../core/scene/types';\n\n/** Options for `useHoverTracking`. */\nexport interface UseHoverTrackingArgs {\n  /** Topmost id under a client point, or null. */\n  nodeAtClientPoint: (clientX: number, clientY: number) => { id: NodeId } | null;\n  enabled?: boolean;\n}\n\n/** What `useHoverTracking` returns. Both members keep their identity. */\nexport interface HoverTracking {\n  /** The node the pointer is over, or null. */\n  getHover: () => NodeId | null;\n  /** Hand it the element to track, or null to stop: a callback ref, so an\n   *  element that mounts after the hook is tracked from the moment it arrives. */\n  canvasRef: (element: HTMLElement | null) => void;\n}\n\n/** Track which node the pointer is over. Returns a getter rather than state,\n *  so a pointer move does not re-render the component. Cleared on\n *  `pointerleave`. */\nexport function useHoverTracking(args: UseHoverTrackingArgs): HoverTracking {\n  const { nodeAtClientPoint, enabled = true } = args;\n  const hoverRef = useRef<NodeId | null>(null);\n  const nodeAtRef = useLatest(nodeAtClientPoint);\n  const elementRef = useRef<HTMLElement | null>(null);\n  const enabledRef = useRef(enabled);\n  const detachRef = useRef<(() => void) | null>(null);\n\n  const sync = useCallback(() => {\n    detachRef.current?.();\n    detachRef.current = null;\n    hoverRef.current = null;\n    const el = elementRef.current;\n    if (!el || !enabledRef.current) return;\n    const onMove = (e: PointerEvent) => {\n      hoverRef.current = nodeAtRef.current(e.clientX, e.clientY)?.id ?? null;\n    };\n    const onLeave = () => { hoverRef.current = null; };\n    el.addEventListener('pointermove', onMove);\n    el.addEventListener('pointerleave', onLeave);\n    detachRef.current = () => {\n      el.removeEventListener('pointermove', onMove);\n      el.removeEventListener('pointerleave', onLeave);\n    };\n  }, [nodeAtRef]);\n\n  useEffect(() => {\n    enabledRef.current = enabled;\n    sync();\n    return () => {\n      detachRef.current?.();\n      detachRef.current = null;\n      hoverRef.current = null;\n    };\n  }, [enabled, sync]);\n\n  const canvasRef = useCallback((element: HTMLElement | null) => {\n    if (elementRef.current === element) return;\n    elementRef.current = element;\n    sync();\n  }, [sync]);\n  const getHover = useCallback(() => hoverRef.current, []);\n\n  return useMemo(() => ({ getHover, canvasRef }), [getHover, canvasRef]);\n}\n"],"mappings":";;;AAyBA,SAAgBA,EAAiB,GAA2C;CAC1E,IAAM,EAAE,sBAAmB,aAAU,OAASC,GACxCC,IAAWC,EAAsB,IAAI,GACrCC,IAAYC,EAAUC,CAAiB,GACvCC,IAAaJ,EAA2B,IAAI,GAC5CK,IAAaL,EAAOM,CAAO,GAC3BC,IAAYP,EAA4B,IAAI,GAE5CQ,IAAOC,QAAkB;EAG7B,AAFAF,EAAU,UAAU,GACpB,EAAU,UAAU,MACpB,EAAS,UAAU;EACnB,IAAMG,IAAKN,EAAW;EACtB,IAAI,CAACM,KAAM,CAACL,EAAW,SAAS;EAChC,IAAMM,KAAU,MAAoB;GAClC,EAAS,UAAUV,EAAU,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM;EACpE,GACMW,UAAgB;GAAE,EAAS,UAAU;EAAM;EAGjD,AAFAF,EAAG,iBAAiB,eAAeC,CAAM,GACzCD,EAAG,iBAAiB,gBAAgBE,CAAO,GAC3C,EAAU,gBAAgB;GAExB,AADAF,EAAG,oBAAoB,eAAeC,CAAM,GAC5CD,EAAG,oBAAoB,gBAAgBE,CAAO;EAChD;CACF,GAAG,CAACX,CAAS,CAAC;CAEd,SACE,EAAW,UAAUK,GACrBE,EAAK,SACQ;EAGX,AAFAD,EAAU,UAAU,GACpB,EAAU,UAAU,MACpB,EAAS,UAAU;CACrB,IACC,CAACD,GAASE,CAAI,CAAC;CAElB,IAAMK,IAAYJ,GAAa,MAAgC;EAC7D,AAAIL,EAAW,YAAYU,MAC3B,EAAW,UAAUA,GACrBN,EAAK;CACP,GAAG,CAACA,CAAI,CAAC,GACHO,IAAWN,QAAkBV,EAAS,SAAS,CAAC,CAAC;CAEvD,OAAOiB,SAAe;EAAE;EAAU;CAAU,IAAI,CAACD,GAAUF,CAAS,CAAC;AACvE"}

package/dist/features/ingestion/contentHandlers.js

@@ -1,40 +1,46 @@
 import { dwarn as e } from "../../debug/flag.js";
-import { mimeMatchesGlob as t } from "@weasel-js/gestures";
+import { UNKNOWN_MIME as t, mimeMatchesGlob as n } from "@weasel-js/gestures";
 //#region src/features/ingestion/contentHandlers.ts
-var n = [];
-function r(e) {
-	return n.push(e), () => {
-		let t = n.indexOf(e);
-		t >= 0 && n.splice(t, 1);
+var r = [];
+function i(e) {
+	return r.push(e), () => {
+		let t = r.indexOf(e);
+		t >= 0 && r.splice(t, 1);
 	};
 }
-function i(e) {
+function a(e) {
 	return [...e].sort((e, t) => (t.priority ?? 0) - (e.priority ?? 0));
 }
-function a() {
-	return i(n);
+function o() {
+	return a(r);
 }
-function o(e, n) {
+function s(e, t) {
 	let { match: r } = e;
 	if (typeof r == "function") try {
-		return r(n);
+		return r(t);
 	} catch (t) {
 		return console.warn(`weasel ingest: handler "${e.id}" match predicate threw`, t), !1;
 	}
-	return (Array.isArray(r) ? r : [r]).some((e) => t(n.mime, e));
+	return (Array.isArray(r) ? r : [r]).some((e) => n(t.mime, e));
+}
+function c(e, i = r) {
+	return e.some((e) => e.kind === void 0 ? e.mime === t || i.some((t) => {
+		let r = typeof t.match == "function" ? t.types : [t.match].flat();
+		return r === void 0 || r.some((t) => n(e.mime, t));
+	}) : i.some((t) => s(t, e)));
 }
-async function s(t, n, r = {}) {
-	let s = t, c = [], l = r.handlers ? i(r.handlers) : a();
+async function l(t, n, r = {}) {
+	let i = t, c = [], l = r.handlers ? a(r.handlers) : o();
 	for (let e of l) {
-		if (s.length === 0) break;
-		let t = s.filter((t) => o(e, t));
-		t.length !== 0 && (s = s.filter((e) => !t.includes(e)), c.push(Promise.resolve().then(() => e.handle(t, n)).catch((t) => {
+		if (i.length === 0) break;
+		let t = i.filter((t) => s(e, t));
+		t.length !== 0 && (i = i.filter((e) => !t.includes(e)), c.push(Promise.resolve().then(() => e.handle(t, n)).catch((t) => {
 			console.warn(`weasel ingest: handler "${e.id}" threw`, t);
 		})));
 	}
-	s.length > 0 && e("ingest", `no content handler matched ${s.length} item(s):`, s.map((e) => e.mime).join(", ")), await Promise.all(c);
+	i.length > 0 && e("ingest", `no content handler matched ${i.length} item(s):`, i.map((e) => e.mime).join(", ")), await Promise.all(c);
 }
 //#endregion
-export { a as getContentHandlers, r as registerContentHandler, s as runIngest };
+export { c as couldClaim, o as getContentHandlers, i as registerContentHandler, l as runIngest };
 
 //# sourceMappingURL=contentHandlers.js.map

package/dist/features/ingestion/contentHandlers.js.map

@@ -1 +1 @@
-{"version":3,"file":"contentHandlers.js","names":["HANDLERS","registerContentHandler","entry","i","byPriority","handlers","b","a","getContentHandlers","entryMatches","match","item","err","mimeMatchesGlob","g","runIngest","remaining","items","runs","opts","mine","it","ctx","dwarn"],"sources":["../../../src/features/ingestion/contentHandlers.ts"],"sourcesContent":["/**\n * Content-handler registry — the \"registry out\" half of external-content\n * ingestion (spec: docs/superpowers/specs/2026-07-03-content-ingestion-design.md).\n *\n * All three arrival paths (OS drop, clipboard paste, file picker /\n * `CanvasExtensionApi.ingest`) converge here: the `ingest` action calls\n * `runIngest(items, ctx)`, which partitions the items across registered\n * handlers in priority order — the first matching handler takes every item\n * it matches; leftovers continue down the list. Same per-trait registry\n * idiom as `NodeShape` / `NodeRouting`. The `clipboard.pasteEvent` action\n * calls it too, with `RunIngestOptions.handlers` naming the one handler it\n * accepts.\n *\n * MIME matching delegates to `mimeMatchesGlob` from `@weasel-js/gestures` —\n * the SAME matcher the binding-level `types` filter uses, so a binding that\n * matched can never disagree with the registry about what a glob means.\n */\nimport { mimeMatchesGlob } from '@weasel-js/gestures';\nimport { dwarn } from '../../debug';\nimport type { Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Op } from 'core/ops/types';\nimport type { ClipboardIngestCtx, InsertDep, SvgIngestOptions } from 'interactions/actions/depSchema';\nimport type { ActionDeps } from '@weasel-js/routing';\nimport type { IngestItem } from '@weasel-js/routing';\n\n/** Context handed to every content handler for one ingest event. */\nexport interface IngestCtx {\n  /** World-space arrival point (drop / pointed imperative ingest); `null`\n   *  for paste and point-less calls — handlers pick their own policy\n   *  (the kit image handler centers on the viewport). */\n  point: { x: number; y: number } | null;\n  /** Visible canvas area in world coordinates. */\n  viewportWorldRect(): { x: number; y: number; width: number; height: number };\n  /** The kit insert dep — id/layer/undoable-op supplied; the canonical way\n   *  for a handler to mint a node (`insert.commit(bounds, { kind, ... })`). */\n  insert: InsertDep;\n  /** Raw op commit for handlers that build their own ops. */\n  applyOps(ops: Op[], label?: string): void;\n  scene: Scene<unknown, string, unknown>;\n  selection: SelectionApi;\n  /** Consumer file→src resolver (SceneCanvas `ingestion.resolveSrc`).\n   *  When absent, the kit image handler embeds as a `data:` URI. */\n  resolveSrc?: (file: File) => Promise<string>;\n  /** Kit SVG-handler options (SceneCanvas `ingestion.svg`) — e.g.\n   *  `{ unpack: unpackSvgFiles }` (from `@weasel-js/svg`) to parse SVG files\n   *  into scene nodes. */\n  svg?: SvgIngestOptions;\n  /** Clipboard-paste seam — present when the hosting `SceneCanvas` supplied\n   *  an adapter with `commitPaste`. `reviver` comes from\n   *  `SceneCanvasProps.ingestion.clipboard`. Absent ⇒ the kit weasel-JSON\n   *  handler declines inert (dwarn, nothing ingested) — its matched items\n   *  were already consumed at match time, so they do NOT fall through;\n   *  only match-level misses flow on to other handlers. */\n  clipboard?: ClipboardIngestCtx;\n  /** Set to `true` by the kit weasel-JSON handler when it successfully\n   *  pastes a payload in this event. The `ctx` object is shared across all\n   *  handlers in one `runIngest` call, and higher-priority handlers' `handle`\n   *  bodies run (synchronously) before lower ones — so `kit:svg`'s\n   *  `text/plain` SVG fallback reads this to decline the SVG flavor of a copy\n   *  whose canonical weasel-JSON flavor already ingested (avoids a\n   *  double-paste when both flavors ride one clipboard event). */\n  consumedWeaselPayload?: boolean;\n  /** Full action-deps bag, for consumer handlers that need more. */\n  deps: ActionDeps;\n}\n\n/** A handler for content arriving by paste, drop or file picker. Handlers are\n *  matched by MIME glob or predicate and run highest-priority first; the kit's\n *  own register at a low priority so a consumer's handler wins by default. */\nexport interface ContentHandlerEntry {\n  /** Stable identifier — used for unregistration and debugging\n   *  (`'kit:image'`, `'app:csv'`). */\n  id: string;\n  /** MIME glob(s) (`'image/*'`, `'text/csv'`) or an item predicate. */\n  match: string | string[] | ((item: IngestItem) => boolean);\n  /** Higher runs earlier. Kit defaults register at -100 so any consumer\n   *  handler (default 0) beats them. */\n  priority?: number;\n  handle(items: IngestItem[], ctx: IngestCtx): void | Promise<void>;\n}\n\nconst HANDLERS: ContentHandlerEntry[] = [];\n\n/** Register a content handler. Returns a disposer that removes it. */\nexport function registerContentHandler(entry: ContentHandlerEntry): () => void {\n  HANDLERS.push(entry);\n  return () => {\n    const i = HANDLERS.indexOf(entry);\n    if (i >= 0) HANDLERS.splice(i, 1);\n  };\n}\n\nfunction byPriority(handlers: readonly ContentHandlerEntry[]): ContentHandlerEntry[] {\n  return [...handlers].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));\n}\n\n/** Snapshot of registered handlers, priority-ordered (stable within ties —\n *  registration order; Array.prototype.sort is stable per ES2019). */\nexport function getContentHandlers(): readonly ContentHandlerEntry[] {\n  return byPriority(HANDLERS);\n}\n\n/** Options for {@link runIngest}. */\nexport interface RunIngestOptions {\n  /**\n   * The handlers to route through, in place of the registry. The registry is\n   * shared by every canvas on the page, so this is how one arrival path\n   * accepts a narrower set of content than the page has handlers for: the\n   * `clipboard.pasteEvent` action passes the kit's node-payload handler alone.\n   * Ordered by `priority` like registered handlers; an item none of them\n   * matches is ignored.\n   */\n  handlers?: readonly ContentHandlerEntry[];\n}\n\nfunction entryMatches(entry: ContentHandlerEntry, item: IngestItem): boolean {\n  const { match } = entry;\n  if (typeof match === 'function') {\n    try {\n      return match(item);\n    } catch (err) {\n      console.warn(`weasel ingest: handler \"${entry.id}\" match predicate threw`, err);\n      return false;\n    }\n  }\n  const globs = Array.isArray(match) ? match : [match];\n  return globs.some((g) => mimeMatchesGlob(item.mime, g));\n}\n\n/**\n * Route one ingest event's items through the registry. Handlers are queued\n * as microtasks in priority order and their async work then overlaps (each\n * already owns a disjoint item set); a throwing or rejecting handler\n * `console.warn`s and doesn't block the others. The queue order is a real\n * invariant: a higher-priority handler's `handle` body runs before lower\n * ones start, so ctx-flag coordination (e.g. `consumedWeaselPayload`)\n * works — but only while the writing handler stays synchronous up to the\n * write and the reading handler reads before its first `await`.\n * Unmatched items are ignored with a debug-gated `dwarn('ingest', ...)`.\n */\nexport async function runIngest(\n  items: IngestItem[],\n  ctx: IngestCtx,\n  opts: RunIngestOptions = {},\n): Promise<void> {\n  let remaining = items;\n  const runs: Promise<void>[] = [];\n  const handlers = opts.handlers ? byPriority(opts.handlers) : getContentHandlers();\n\n  for (const entry of handlers) {\n    if (remaining.length === 0) break;\n    const mine = remaining.filter((it) => entryMatches(entry, it));\n    if (mine.length === 0) continue;\n    remaining = remaining.filter((it) => !mine.includes(it));\n    runs.push(\n      Promise.resolve()\n        .then(() => entry.handle(mine, ctx))\n        .catch((err) => {\n          console.warn(`weasel ingest: handler \"${entry.id}\" threw`, err);\n        }),\n    );\n  }\n\n  if (remaining.length > 0) {\n    dwarn(\n      'ingest',\n      `no content handler matched ${remaining.length} item(s):`,\n      remaining.map((it) => it.mime).join(', '),\n    );\n  }\n\n  await Promise.all(runs);\n}\n\n/** @internal test seam — clear the registry. Not part of the public barrel. */\nexport function _resetContentHandlersForTests(): void {\n  HANDLERS.length = 0;\n}\n"],"mappings":";;;AAkFA,IAAMA,IAAkC,CAAC;AAGzC,SAAgBC,EAAuB,GAAwC;CAE7E,OADAD,EAAS,KAAKE,CAAK,SACN;EACX,IAAMC,IAAIH,EAAS,QAAQE,CAAK;EAChC,AAAIC,KAAK,KAAGH,EAAS,OAAOG,GAAG,CAAC;CAClC;AACF;AAEA,SAASC,EAAW,GAAiE;CACnF,OAAO,CAAC,GAAGC,CAAQ,CAAC,CAAC,MAAM,GAAG,OAAOC,EAAE,YAAY,MAAMC,EAAE,YAAY,EAAE;AAC3E;AAIA,SAAgBC,IAAqD;CACnE,OAAOJ,EAAWJ,CAAQ;AAC5B;AAeA,SAASS,EAAa,GAA4B,GAA2B;CAC3E,IAAM,EAAE,aAAUP;CAClB,IAAI,OAAOQ,KAAU,YACnB,IAAI;EACF,OAAOA,EAAMC,CAAI;CACnB,SAASC,GAAK;EAEZ,OADA,QAAQ,KAAK,2BAA2BV,EAAM,GAAG,0BAA0BU,CAAG,GACvE;CACT;CAGF,QADc,MAAM,QAAQF,CAAK,IAAIA,IAAQ,CAACA,CAAK,EAAA,CACtC,MAAM,MAAMG,EAAgBF,EAAK,MAAMG,CAAC,CAAC;AACxD;AAaA,eAAsBC,EACpB,GACA,GACA,IAAyB,CAAC,GACX;CACf,IAAIC,IAAYC,GACVC,IAAwB,CAAC,GACzBb,IAAWc,EAAK,WAAWf,EAAWe,EAAK,QAAQ,IAAIX,EAAmB;CAEhF,KAAK,IAAMN,KAASG,GAAU;EAC5B,IAAIW,EAAU,WAAW,GAAG;EAC5B,IAAMI,IAAOJ,EAAU,QAAQ,MAAOP,EAAaP,GAAOmB,CAAE,CAAC;EAC7D,AAAID,EAAK,WAAW,MACpB,IAAYJ,EAAU,QAAQ,MAAO,CAACI,EAAK,SAASC,CAAE,CAAC,GACvDH,EAAK,KACH,QAAQ,QAAQ,CAAC,CACd,WAAWhB,EAAM,OAAOkB,GAAME,CAAG,CAAC,CAAC,CACnC,OAAO,MAAQ;GACd,QAAQ,KAAK,2BAA2BpB,EAAM,GAAG,UAAUU,CAAG;EAChE,CAAC,CACL;CACF;CAUA,AARII,EAAU,SAAS,KACrBO,EACE,UACA,8BAA8BP,EAAU,OAAO,YAC/CA,EAAU,KAAK,MAAOK,EAAG,IAAI,CAAC,CAAC,KAAK,IAAI,CAC1C,GAGF,MAAM,QAAQ,IAAIH,CAAI;AACxB"}
+{"version":3,"file":"contentHandlers.js","names":["HANDLERS","registerContentHandler","entry","i","byPriority","handlers","b","a","getContentHandlers","entryMatches","match","item","err","mimeMatchesGlob","g","couldClaim","items","UNKNOWN_MIME","globs","h","runIngest","remaining","runs","opts","mine","it","ctx","dwarn"],"sources":["../../../src/features/ingestion/contentHandlers.ts"],"sourcesContent":["/**\n * Content-handler registry for external-content ingestion.\n *\n * All three arrival paths (OS drop, clipboard paste, file picker /\n * `CanvasExtensionApi.ingest`) converge here: `runIngest(items, ctx)`\n * partitions the items across registered handlers in priority order — the\n * first matching handler takes every item it matches; leftovers continue\n * down the list.\n *\n * MIME matching delegates to `mimeMatchesGlob` from `@weasel-js/gestures` —\n * the SAME matcher the binding-level `types` filter uses, so a binding that\n * matched can never disagree with the registry about what a glob means.\n */\nimport { mimeMatchesGlob, UNKNOWN_MIME } from '@weasel-js/gestures';\nimport { dwarn } from '../../debug';\nimport type { Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Op } from 'core/ops/types';\nimport type { ClipboardIngestCtx, InsertDep, SvgIngestOptions } from 'interactions/actions/depSchema';\nimport type { ActionDeps } from '@weasel-js/routing';\nimport type { IngestItem } from '@weasel-js/routing';\n\n/** Context handed to every content handler for one ingest event. */\nexport interface IngestCtx {\n  /** World-space arrival point (drop / pointed imperative ingest); `null`\n   *  for paste and point-less calls — handlers pick their own policy\n   *  (the kit image handler centers on the viewport). */\n  point: { x: number; y: number } | null;\n  /** Visible canvas area in world coordinates. */\n  viewportWorldRect(): { x: number; y: number; width: number; height: number };\n  /** The kit insert dep — id/layer/undoable-op supplied; the canonical way\n   *  for a handler to mint a node (`insert.commit(bounds, { kind, ... })`). */\n  insert: InsertDep;\n  /** Raw op commit for handlers that build their own ops. */\n  applyOps(ops: Op[], label?: string): void;\n  scene: Scene<unknown, string, unknown>;\n  selection: SelectionApi;\n  /** Consumer file→src resolver (SceneCanvas `ingestion.resolveSrc`).\n   *  When absent, the kit image handler embeds as a `data:` URI. */\n  resolveSrc?: (file: File) => Promise<string>;\n  /** Kit SVG-handler options (SceneCanvas `ingestion.svg`) — e.g.\n   *  `{ unpack: unpackSvgFiles }` (from `@weasel-js/svg`) to parse SVG files\n   *  into scene nodes. */\n  svg?: SvgIngestOptions;\n  /** Clipboard-paste seam — present when the hosting `SceneCanvas` supplied\n   *  an adapter with `commitPaste`. `reviver` comes from\n   *  `SceneCanvasProps.ingestion.clipboard`. Absent ⇒ the kit weasel-JSON\n   *  handler declines inert (dwarn, nothing ingested) — its matched items\n   *  were already consumed at match time, so they do NOT fall through;\n   *  only match-level misses flow on to other handlers. */\n  clipboard?: ClipboardIngestCtx;\n  /** Set to `true` by the kit weasel-JSON handler when it successfully\n   *  pastes a payload in this event. `kit:svg`'s `text/plain` SVG fallback\n   *  reads this to decline the SVG flavor of a copy whose weasel-JSON flavor\n   *  already ingested (avoids a double-paste when both flavors ride one\n   *  clipboard event). */\n  consumedWeaselPayload?: boolean;\n  /** Full action-deps bag, for consumer handlers that need more. */\n  deps: ActionDeps;\n}\n\n/** A handler for content arriving by paste, drop or file picker. Handlers are\n *  matched by MIME glob or predicate and run highest-priority first; the kit's\n *  own register at a low priority so a consumer's handler wins by default. */\nexport interface ContentHandlerEntry {\n  /** Stable identifier — used for unregistration and debugging\n   *  (`'kit:image'`, `'app:csv'`). */\n  id: string;\n  /** MIME glob(s) (`'image/*'`, `'text/csv'`) or an item predicate. */\n  match: string | string[] | ((item: IngestItem) => boolean);\n  /** For a predicate `match`: the MIME globs it could say yes to. A drag\n   *  still in flight shows its MIMEs and no contents, so a predicate cannot be\n   *  asked about it; this is what it is asked instead. Without it, no drag\n   *  can be refused while this handler is registered. */\n  types?: readonly string[];\n  /** Higher runs earlier. Kit defaults register at -100 so any consumer\n   *  handler (default 0) beats them. */\n  priority?: number;\n  handle(items: IngestItem[], ctx: IngestCtx): void | Promise<void>;\n}\n\nconst HANDLERS: ContentHandlerEntry[] = [];\n\n/** Register a content handler. Returns a disposer that removes it. */\nexport function registerContentHandler(entry: ContentHandlerEntry): () => void {\n  HANDLERS.push(entry);\n  return () => {\n    const i = HANDLERS.indexOf(entry);\n    if (i >= 0) HANDLERS.splice(i, 1);\n  };\n}\n\nfunction byPriority(handlers: readonly ContentHandlerEntry[]): ContentHandlerEntry[] {\n  return [...handlers].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));\n}\n\n/** Snapshot of registered handlers, priority-ordered (stable within ties —\n *  registration order; Array.prototype.sort is stable per ES2019). */\nexport function getContentHandlers(): readonly ContentHandlerEntry[] {\n  return byPriority(HANDLERS);\n}\n\n/** Options for {@link runIngest}. */\nexport interface RunIngestOptions {\n  /**\n   * The handlers to route through, in place of the registry. The registry is\n   * shared by every canvas on the page, so this is how one arrival path\n   * accepts a narrower set of content than the page has handlers for.\n   * Ordered by `priority` like registered handlers; an item none of them\n   * matches is ignored.\n   */\n  handlers?: readonly ContentHandlerEntry[];\n}\n\nfunction entryMatches(entry: ContentHandlerEntry, item: IngestItem): boolean {\n  const { match } = entry;\n  if (typeof match === 'function') {\n    try {\n      return match(item);\n    } catch (err) {\n      console.warn(`weasel ingest: handler \"${entry.id}\" match predicate threw`, err);\n      return false;\n    }\n  }\n  const globs = Array.isArray(match) ? match : [match];\n  return globs.some((g) => mimeMatchesGlob(item.mime, g));\n}\n\n/**\n * Whether some handler could claim one of `items`: the registry's, or\n * `handlers`. An item with contents is put to each handler's `match`. One\n * with a MIME alone, from a drag still in flight, is answered from the globs\n * and a predicate's declared `types`; it is never refused when its MIME is\n * `UNKNOWN_MIME`, or while a predicate handler declares no types.\n */\nexport function couldClaim(\n  items: readonly IngestItem[],\n  handlers: readonly ContentHandlerEntry[] = HANDLERS,\n): boolean {\n  return items.some((item) => {\n    if ((item as { kind?: string }).kind !== undefined) return handlers.some((h) => entryMatches(h, item));\n    if (item.mime === UNKNOWN_MIME) return true;\n    return handlers.some((h) => {\n      const globs = typeof h.match === 'function' ? h.types : [h.match].flat();\n      return globs === undefined || globs.some((g) => mimeMatchesGlob(item.mime, g));\n    });\n  });\n}\n\n/**\n * Route one ingest event's items through the registry. Handlers are queued\n * as microtasks in priority order and their async work then overlaps (each\n * already owns a disjoint item set); a throwing or rejecting handler\n * `console.warn`s and doesn't block the others. The queue order is a real\n * invariant: a higher-priority handler's `handle` body runs before lower\n * ones start, so ctx-flag coordination (e.g. `consumedWeaselPayload`)\n * works — but only while the writing handler stays synchronous up to the\n * write and the reading handler reads before its first `await`.\n * Unmatched items are ignored with a debug-gated `dwarn('ingest', ...)`.\n */\nexport async function runIngest(\n  items: IngestItem[],\n  ctx: IngestCtx,\n  opts: RunIngestOptions = {},\n): Promise<void> {\n  let remaining = items;\n  const runs: Promise<void>[] = [];\n  const handlers = opts.handlers ? byPriority(opts.handlers) : getContentHandlers();\n\n  for (const entry of handlers) {\n    if (remaining.length === 0) break;\n    const mine = remaining.filter((it) => entryMatches(entry, it));\n    if (mine.length === 0) continue;\n    remaining = remaining.filter((it) => !mine.includes(it));\n    runs.push(\n      Promise.resolve()\n        .then(() => entry.handle(mine, ctx))\n        .catch((err) => {\n          console.warn(`weasel ingest: handler \"${entry.id}\" threw`, err);\n        }),\n    );\n  }\n\n  if (remaining.length > 0) {\n    dwarn(\n      'ingest',\n      `no content handler matched ${remaining.length} item(s):`,\n      remaining.map((it) => it.mime).join(', '),\n    );\n  }\n\n  await Promise.all(runs);\n}\n\n/** @internal test seam — clear the registry. Not part of the public barrel. */\nexport function _resetContentHandlersForTests(): void {\n  HANDLERS.length = 0;\n}\n"],"mappings":";;;AAiFA,IAAMA,IAAkC,CAAC;AAGzC,SAAgBC,EAAuB,GAAwC;CAE7E,OADAD,EAAS,KAAKE,CAAK,SACN;EACX,IAAMC,IAAIH,EAAS,QAAQE,CAAK;EAChC,AAAIC,KAAK,KAAGH,EAAS,OAAOG,GAAG,CAAC;CAClC;AACF;AAEA,SAASC,EAAW,GAAiE;CACnF,OAAO,CAAC,GAAGC,CAAQ,CAAC,CAAC,MAAM,GAAG,OAAOC,EAAE,YAAY,MAAMC,EAAE,YAAY,EAAE;AAC3E;AAIA,SAAgBC,IAAqD;CACnE,OAAOJ,EAAWJ,CAAQ;AAC5B;AAcA,SAASS,EAAa,GAA4B,GAA2B;CAC3E,IAAM,EAAE,aAAUP;CAClB,IAAI,OAAOQ,KAAU,YACnB,IAAI;EACF,OAAOA,EAAMC,CAAI;CACnB,SAASC,GAAK;EAEZ,OADA,QAAQ,KAAK,2BAA2BV,EAAM,GAAG,0BAA0BU,CAAG,GACvE;CACT;CAGF,QADc,MAAM,QAAQF,CAAK,IAAIA,IAAQ,CAACA,CAAK,EAAA,CACtC,MAAM,MAAMG,EAAgBF,EAAK,MAAMG,CAAC,CAAC;AACxD;AASA,SAAgBC,EACd,GACA,IAA2Cf,GAClC;CACT,OAAOgB,EAAM,MAAM,MACZL,EAA2B,SAAS,KAAA,IACrCA,EAAK,SAASM,KACXZ,EAAS,MAAM,MAAM;EAC1B,IAAMa,IAAQ,OAAOC,EAAE,SAAU,aAAaA,EAAE,QAAQ,CAACA,EAAE,KAAK,CAAC,CAAC,KAAK;EACvE,OAAOD,MAAU,KAAA,KAAaA,EAAM,MAAM,MAAML,EAAgBF,EAAK,MAAMG,CAAC,CAAC;CAC/E,CAAC,IAL0DT,EAAS,MAAM,MAAMI,EAAaU,GAAGR,CAAI,CAAC,CAMtG;AACH;AAaA,eAAsBS,EACpB,GACA,GACA,IAAyB,CAAC,GACX;CACf,IAAIC,IAAYL,GACVM,IAAwB,CAAC,GACzBjB,IAAWkB,EAAK,WAAWnB,EAAWmB,EAAK,QAAQ,IAAIf,EAAmB;CAEhF,KAAK,IAAMN,KAASG,GAAU;EAC5B,IAAIgB,EAAU,WAAW,GAAG;EAC5B,IAAMG,IAAOH,EAAU,QAAQ,MAAOZ,EAAaP,GAAOuB,CAAE,CAAC;EAC7D,AAAID,EAAK,WAAW,MACpB,IAAYH,EAAU,QAAQ,MAAO,CAACG,EAAK,SAASC,CAAE,CAAC,GACvDH,EAAK,KACH,QAAQ,QAAQ,CAAC,CACd,WAAWpB,EAAM,OAAOsB,GAAME,CAAG,CAAC,CAAC,CACnC,OAAO,MAAQ;GACd,QAAQ,KAAK,2BAA2BxB,EAAM,GAAG,UAAUU,CAAG;EAChE,CAAC,CACL;CACF;CAUA,AARIS,EAAU,SAAS,KACrBM,EACE,UACA,8BAA8BN,EAAU,OAAO,YAC/CA,EAAU,KAAK,MAAOI,EAAG,IAAI,CAAC,CAAC,KAAK,IAAI,CAC1C,GAGF,MAAM,QAAQ,IAAIH,CAAI;AACxB"}

package/dist/features/ingestion/imageHandler.js

@@ -1,45 +1,42 @@
+import { arrivalBounds as e } from "./placement.js";
 //#region src/features/ingestion/imageHandler.ts
-var e = .9, t = async (e) => {
+var t = .9, n = async (e) => {
 	let t = await createImageBitmap(e), n = {
 		width: t.width,
 		height: t.height
 	};
 	return t.close(), n;
-}, n = (e) => new Promise((t, n) => {
+}, r = (e) => new Promise((t, n) => {
 	let r = new FileReader();
 	r.onload = () => t(r.result), r.onerror = () => n(r.error), r.readAsDataURL(e);
-}), r = t, i = n;
-async function a(t, n, a = {}) {
-	let o = 0;
-	for (let s of t) try {
-		let t = await (a.measure ?? r)(s), c = n.resolveSrc ? await n.resolveSrc(s) : await i(s);
-		!n.resolveSrc && a.mimeOverride && (c = c.replace(/^data:[^;,]*/, `data:${a.mimeOverride}`));
-		let l = n.viewportWorldRect(), u = Math.min(1, l.width * e / t.width, l.height * e / t.height), d = t.width * u, f = t.height * u, p = n.point ?? {
-			x: l.x + l.width / 2,
-			y: l.y + l.height / 2
-		}, m = o * 24;
-		n.insert.commit({
-			x: p.x - d / 2 + m,
-			y: p.y - f / 2 + m,
-			width: d,
-			height: f
-		}, {
+}), i = n, a = r;
+async function o(n, r, o = {}) {
+	let s = 0;
+	for (let c of n) try {
+		let n = await (o.measure ?? i)(c), l = r.resolveSrc ? await r.resolveSrc(c) : await a(c);
+		!r.resolveSrc && o.mimeOverride && (l = l.replace(/^data:[^;,]*/, `data:${o.mimeOverride}`));
+		let u = r.viewportWorldRect(), d = Math.min(1, u.width * t / n.width, u.height * t / n.height), f = {
+			width: n.width * d,
+			height: n.height * d
+		};
+		r.insert.commit(e(r, f, s), {
 			kind: "image",
-			src: c
-		}), o++;
+			src: l
+		}), s++;
 	} catch (e) {
-		console.warn(`weasel ingest: image "${s.name}" failed to load`, e);
+		console.warn(`weasel ingest: image "${c.name}" failed to load`, e);
 	}
 }
-var o = {
+var s = {
 	id: "kit:image",
 	match: (e) => e.kind === "file" && e.mime.startsWith("image/"),
+	types: ["image/*"],
 	priority: -100,
 	handle(e, t) {
-		return a(e.flatMap((e) => e.kind === "file" ? [e.file] : []), t);
+		return o(e.flatMap((e) => e.kind === "file" ? [e.file] : []), t);
 	}
 };
 //#endregion
-export { a as embedFilesAsImageNodes, o as kitImageHandler };
+export { o as embedFilesAsImageNodes, s as kitImageHandler };
 
 //# sourceMappingURL=imageHandler.js.map

package/dist/features/ingestion/imageHandler.js.map

@@ -1 +1 @@
-{"version":3,"file":"imageHandler.js","names":["VIEWPORT_FIT","defaultMeasure","bitmap","file","size","defaultToDataUri","reader","resolve","reject","measure","toDataUri","embedFilesAsImageNodes","index","files","natural","opts","src","ctx","view","scale","width","height","center","offset","err","kitImageHandler","item","items","it"],"sources":["../../../src/features/ingestion/imageHandler.ts"],"sourcesContent":["/**\n * The kit's `image/*` content handler — the one handler shipped by default.\n *\n * For each image file: resolve a `src` (consumer `resolveSrc` when provided,\n * else embed as a `data:` URI so the scene stays serializable), measure the\n * natural pixel size, fit-clamp to 90% of the visible viewport, and insert a\n * leaf node with `data.image = { src }` via the insert dep (id/layer/undoable\n * op supplied there — same contract as `useImageTool`).\n *\n * Placement: centered on `ctx.point` (drop / pointed ingest) or the viewport\n * center (paste / point-less). Multi-file ingests cascade by a fixed offset.\n *\n * Registered at priority -100 so any consumer handler (default 0) can take\n * image files first.\n */\nimport type { ContentHandlerEntry, IngestCtx } from './contentHandlers';\nimport type { IngestItem } from '@weasel-js/routing';\n\nconst CASCADE_OFFSET_PX = 24;\nconst VIEWPORT_FIT = 0.9;\n\nexport type Measure = (file: File) => Promise<{ width: number; height: number }>;\ntype ToDataUri = (file: File) => Promise<string>;\n\nconst defaultMeasure: Measure = async (file) => {\n  const bitmap = await createImageBitmap(file);\n  const size = { width: bitmap.width, height: bitmap.height };\n  bitmap.close();\n  return size;\n};\n\nconst defaultToDataUri: ToDataUri = (file) =>\n  new Promise((resolve, reject) => {\n    const reader = new FileReader();\n    reader.onload = () => resolve(reader.result as string);\n    reader.onerror = () => reject(reader.error);\n    reader.readAsDataURL(file);\n  });\n\nlet measure: Measure = defaultMeasure;\nlet toDataUri: ToDataUri = defaultToDataUri;\n\n/** @internal Options for {@link embedFilesAsImageNodes} — used by the kit\n *  SVG handler, whose files can't go through `createImageBitmap`. */\nexport interface EmbedImageOptions {\n  /** Replace the raster measurer for these files (the SVG handler supplies\n   *  an `Image`-element one). Defaults to the module measurer (seam-aware). */\n  measure?: Measure;\n  /** Force the data-URI MIME. A sniffed `.svg` whose `File.type` was empty\n   *  would otherwise embed as `data:application/octet-stream;…`, which\n   *  browsers refuse to rasterize. No effect on `resolveSrc` output. */\n  mimeOverride?: string;\n}\n\n/**\n * @internal The shared embed engine: for each file, measure → resolve a\n * `src` → fit-clamp to 90% of the visible viewport → insert one image node\n * centered on `ctx.point` (or the viewport center), cascading multi-file\n * batches by a fixed offset. A file that fails to measure or resolve is\n * skipped with a `console.warn`; the rest proceed.\n */\nexport async function embedFilesAsImageNodes(\n  files: File[],\n  ctx: IngestCtx,\n  opts: EmbedImageOptions = {},\n): Promise<void> {\n  let index = 0;\n  for (const file of files) {\n    try {\n      // Measure first: a corrupt file should fail cheaply here, not after\n      // a consumer `resolveSrc` has already uploaded it somewhere.\n      const natural = await (opts.measure ?? measure)(file);\n      let src = ctx.resolveSrc ? await ctx.resolveSrc(file) : await toDataUri(file);\n      if (!ctx.resolveSrc && opts.mimeOverride) {\n        src = src.replace(/^data:[^;,]*/, `data:${opts.mimeOverride}`);\n      }\n      const view = ctx.viewportWorldRect();\n      const scale = Math.min(\n        1,\n        (view.width * VIEWPORT_FIT) / natural.width,\n        (view.height * VIEWPORT_FIT) / natural.height,\n      );\n      const width = natural.width * scale;\n      const height = natural.height * scale;\n      const center = ctx.point ?? {\n        x: view.x + view.width / 2,\n        y: view.y + view.height / 2,\n      };\n      const offset = index * CASCADE_OFFSET_PX;\n      ctx.insert.commit(\n        {\n          x: center.x - width / 2 + offset,\n          y: center.y - height / 2 + offset,\n          width,\n          height,\n        },\n        { kind: 'image', src },\n      );\n      index++;\n    } catch (err) {\n      console.warn(`weasel ingest: image \"${file.name}\" failed to load`, err);\n    }\n  }\n}\n\nexport const kitImageHandler: ContentHandlerEntry = {\n  id: 'kit:image',\n  match: (item: IngestItem) => item.kind === 'file' && item.mime.startsWith('image/'),\n  priority: -100,\n  handle(items, ctx: IngestCtx) {\n    const files = items.flatMap((it) => (it.kind === 'file' ? [it.file] : []));\n    return embedFilesAsImageNodes(files, ctx);\n  },\n};\n\n/** @internal test seam — override the bitmap measurer (jsdom has no\n *  `createImageBitmap`). Not part of the public barrel. */\nexport function __setImageMeasureForTests(fn: Measure): void {\n  measure = fn;\n}\n\n/** @internal test seam — override the FileReader embed. */\nexport function __setFileToDataUriForTests(fn: ToDataUri): void {\n  toDataUri = fn;\n}\n\n/** @internal test seam — restore default seams. */\nexport function _resetImageHandlerSeamsForTests(): void {\n  measure = defaultMeasure;\n  toDataUri = defaultToDataUri;\n}\n"],"mappings":";AAkBA,IACMA,IAAe,IAKfC,IAA0B,OAAO,MAAS;CAC9C,IAAMC,IAAS,MAAM,kBAAkBC,CAAI,GACrCC,IAAO;EAAE,OAAOF,EAAO;EAAO,QAAQA,EAAO;CAAO;CAE1D,OADAA,EAAO,MAAM,GACNE;AACT,GAEMC,KAA+B,MACnC,IAAI,SAAS,GAAS,MAAW;CAC/B,IAAMC,IAAS,IAAI,WAAW;CAG9B,AAFA,EAAO,eAAeC,EAAQD,EAAO,MAAgB,GACrD,EAAO,gBAAgBE,EAAOF,EAAO,KAAK,GAC1CA,EAAO,cAAcH,CAAI;AAC3B,CAAC,GAECM,IAAmBR,GACnBS,IAAuBL;AAqB3B,eAAsBM,EACpB,GACA,GACA,IAA0B,CAAC,GACZ;CACf,IAAIC,IAAQ;CACZ,KAAK,IAAMT,KAAQU,GACjB,IAAI;EAGF,IAAMC,IAAU,OAAOC,EAAK,WAAWN,EAAA,CAASN,CAAI,GAChDa,IAAMC,EAAI,aAAa,MAAMA,EAAI,WAAWd,CAAI,IAAI,MAAMO,EAAUP,CAAI;EAC5E,AAAI,CAACc,EAAI,cAAcF,EAAK,iBAC1B,IAAMC,EAAI,QAAQ,gBAAgB,QAAQD,EAAK,cAAc;EAE/D,IAAMG,IAAOD,EAAI,kBAAkB,GAC7BE,IAAQ,KAAK,IACjB,GACCD,EAAK,QAAQlB,IAAgBc,EAAQ,OACrCI,EAAK,SAASlB,IAAgBc,EAAQ,MACzC,GACMM,IAAQN,EAAQ,QAAQK,GACxBE,IAASP,EAAQ,SAASK,GAC1BG,IAASL,EAAI,SAAS;GAC1B,GAAGC,EAAK,IAAIA,EAAK,QAAQ;GACzB,GAAGA,EAAK,IAAIA,EAAK,SAAS;EAC5B,GACMK,IAASX,IAAQ;EAUvB,AATAK,EAAI,OAAO,OACT;GACE,GAAGK,EAAO,IAAIF,IAAQ,IAAIG;GAC1B,GAAGD,EAAO,IAAID,IAAS,IAAIE;GAC3B;GACA;EACF,GACA;GAAE,MAAM;GAAS;EAAI,CACvB,GACA;CACF,SAASC,GAAK;EACZ,QAAQ,KAAK,yBAAyBrB,EAAK,KAAK,mBAAmBqB,CAAG;CACxE;AAEJ;AAEA,IAAaC,IAAuC;CAClD,IAAI;CACJ,QAAQ,MAAqBC,EAAK,SAAS,UAAUA,EAAK,KAAK,WAAW,QAAQ;CAClF,UAAU;CACV,OAAO,GAAO,GAAgB;EAE5B,OAAOf,EADOgB,EAAM,SAAS,MAAQC,EAAG,SAAS,SAAS,CAACA,EAAG,IAAI,IAAI,CAAC,CACzC,GAAOX,CAAG;CAC1C;AACF"}
+{"version":3,"file":"imageHandler.js","names":["VIEWPORT_FIT","defaultMeasure","bitmap","file","size","defaultToDataUri","reader","resolve","reject","measure","toDataUri","embedFilesAsImageNodes","index","files","natural","opts","src","ctx","view","scale","arrivalBounds","err","kitImageHandler","item","items","it"],"sources":["../../../src/features/ingestion/imageHandler.ts"],"sourcesContent":["/**\n * The kit's `image/*` content handler. With no consumer `resolveSrc`, a file\n * embeds as a `data:` URI so the scene stays serializable.\n *\n * Registered at priority -100 so any consumer handler (default 0) can take\n * image files first.\n */\nimport type { ContentHandlerEntry, IngestCtx } from './contentHandlers';\nimport type { IngestItem } from '@weasel-js/routing';\nimport { arrivalBounds } from './placement';\n\nconst VIEWPORT_FIT = 0.9;\n\nexport type Measure = (file: File) => Promise<{ width: number; height: number }>;\ntype ToDataUri = (file: File) => Promise<string>;\n\nconst defaultMeasure: Measure = async (file) => {\n  const bitmap = await createImageBitmap(file);\n  const size = { width: bitmap.width, height: bitmap.height };\n  bitmap.close();\n  return size;\n};\n\nconst defaultToDataUri: ToDataUri = (file) =>\n  new Promise((resolve, reject) => {\n    const reader = new FileReader();\n    reader.onload = () => resolve(reader.result as string);\n    reader.onerror = () => reject(reader.error);\n    reader.readAsDataURL(file);\n  });\n\nlet measure: Measure = defaultMeasure;\nlet toDataUri: ToDataUri = defaultToDataUri;\n\n/** @internal Options for {@link embedFilesAsImageNodes} — used by the kit\n *  SVG handler, whose files can't go through `createImageBitmap`. */\nexport interface EmbedImageOptions {\n  /** Replace the raster measurer for these files (the SVG handler supplies\n   *  an `Image`-element one). Defaults to the module measurer (seam-aware). */\n  measure?: Measure;\n  /** Force the data-URI MIME. A sniffed `.svg` whose `File.type` was empty\n   *  would otherwise embed as `data:application/octet-stream;…`, which\n   *  browsers refuse to rasterize. No effect on `resolveSrc` output. */\n  mimeOverride?: string;\n}\n\n/**\n * @internal The shared embed engine: for each file, measure → resolve a\n * `src` → fit-clamp to 90% of the visible viewport → insert one image node\n * centered on `ctx.point` (or the viewport center), cascading multi-file\n * batches by a fixed offset. A file that fails to measure or resolve is\n * skipped with a `console.warn`; the rest proceed.\n */\nexport async function embedFilesAsImageNodes(\n  files: File[],\n  ctx: IngestCtx,\n  opts: EmbedImageOptions = {},\n): Promise<void> {\n  let index = 0;\n  for (const file of files) {\n    try {\n      // Measure first: a corrupt file should fail cheaply here, not after\n      // a consumer `resolveSrc` has already uploaded it somewhere.\n      const natural = await (opts.measure ?? measure)(file);\n      let src = ctx.resolveSrc ? await ctx.resolveSrc(file) : await toDataUri(file);\n      if (!ctx.resolveSrc && opts.mimeOverride) {\n        src = src.replace(/^data:[^;,]*/, `data:${opts.mimeOverride}`);\n      }\n      const view = ctx.viewportWorldRect();\n      const scale = Math.min(\n        1,\n        (view.width * VIEWPORT_FIT) / natural.width,\n        (view.height * VIEWPORT_FIT) / natural.height,\n      );\n      const size = { width: natural.width * scale, height: natural.height * scale };\n      ctx.insert.commit(arrivalBounds(ctx, size, index), { kind: 'image', src });\n      index++;\n    } catch (err) {\n      console.warn(`weasel ingest: image \"${file.name}\" failed to load`, err);\n    }\n  }\n}\n\nexport const kitImageHandler: ContentHandlerEntry = {\n  id: 'kit:image',\n  match: (item: IngestItem) => item.kind === 'file' && item.mime.startsWith('image/'),\n  types: ['image/*'],\n  priority: -100,\n  handle(items, ctx: IngestCtx) {\n    const files = items.flatMap((it) => (it.kind === 'file' ? [it.file] : []));\n    return embedFilesAsImageNodes(files, ctx);\n  },\n};\n\n/** @internal test seam — override the bitmap measurer (jsdom has no\n *  `createImageBitmap`). Not part of the public barrel. */\nexport function __setImageMeasureForTests(fn: Measure): void {\n  measure = fn;\n}\n\n/** @internal test seam — override the FileReader embed. */\nexport function __setFileToDataUriForTests(fn: ToDataUri): void {\n  toDataUri = fn;\n}\n\n/** @internal test seam — restore default seams. */\nexport function _resetImageHandlerSeamsForTests(): void {\n  measure = defaultMeasure;\n  toDataUri = defaultToDataUri;\n}\n"],"mappings":";;AAWA,IAAMA,IAAe,IAKfC,IAA0B,OAAO,MAAS;CAC9C,IAAMC,IAAS,MAAM,kBAAkBC,CAAI,GACrCC,IAAO;EAAE,OAAOF,EAAO;EAAO,QAAQA,EAAO;CAAO;CAE1D,OADAA,EAAO,MAAM,GACNE;AACT,GAEMC,KAA+B,MACnC,IAAI,SAAS,GAAS,MAAW;CAC/B,IAAMC,IAAS,IAAI,WAAW;CAG9B,AAFA,EAAO,eAAeC,EAAQD,EAAO,MAAgB,GACrD,EAAO,gBAAgBE,EAAOF,EAAO,KAAK,GAC1CA,EAAO,cAAcH,CAAI;AAC3B,CAAC,GAECM,IAAmBR,GACnBS,IAAuBL;AAqB3B,eAAsBM,EACpB,GACA,GACA,IAA0B,CAAC,GACZ;CACf,IAAIC,IAAQ;CACZ,KAAK,IAAMT,KAAQU,GACjB,IAAI;EAGF,IAAMC,IAAU,OAAOC,EAAK,WAAWN,EAAA,CAASN,CAAI,GAChDa,IAAMC,EAAI,aAAa,MAAMA,EAAI,WAAWd,CAAI,IAAI,MAAMO,EAAUP,CAAI;EAC5E,AAAI,CAACc,EAAI,cAAcF,EAAK,iBAC1B,IAAMC,EAAI,QAAQ,gBAAgB,QAAQD,EAAK,cAAc;EAE/D,IAAMG,IAAOD,EAAI,kBAAkB,GAC7BE,IAAQ,KAAK,IACjB,GACCD,EAAK,QAAQlB,IAAgBc,EAAQ,OACrCI,EAAK,SAASlB,IAAgBc,EAAQ,MACzC,GACMV,IAAO;GAAE,OAAOU,EAAQ,QAAQK;GAAO,QAAQL,EAAQ,SAASK;EAAM;EAE5E,AADAF,EAAI,OAAO,OAAOG,EAAcH,GAAKb,GAAMQ,CAAK,GAAG;GAAE,MAAM;GAAS;EAAI,CAAC,GACzE;CACF,SAASS,GAAK;EACZ,QAAQ,KAAK,yBAAyBlB,EAAK,KAAK,mBAAmBkB,CAAG;CACxE;AAEJ;AAEA,IAAaC,IAAuC;CAClD,IAAI;CACJ,QAAQ,MAAqBC,EAAK,SAAS,UAAUA,EAAK,KAAK,WAAW,QAAQ;CAClF,OAAO,CAAC,SAAS;CACjB,UAAU;CACV,OAAO,GAAO,GAAgB;EAE5B,OAAOZ,EADOa,EAAM,SAAS,MAAQC,EAAG,SAAS,SAAS,CAACA,EAAG,IAAI,IAAI,CAAC,CACzC,GAAOR,CAAG;CAC1C;AACF"}

package/dist/features/ingestion/openFilePicker.js.map

@@ -1 +1 @@
-{"version":3,"file":"openFilePicker.js","names":["openFilePicker","input","opts","finish","resolve","files"],"sources":["../../../src/features/ingestion/openFilePicker.ts"],"sourcesContent":["/**\n * `openFilePicker` — tiny DOM helper opening the OS file dialog and resolving\n * the chosen `File[]` ([] on cancel). Pairs with `CanvasExtensionApi.ingest`:\n *\n * ```ts\n * const files = await openFilePicker({ accept: 'image/*', multiple: true });\n * canvasRef.current?.ingest(files);\n * ```\n *\n * Must be called from a user-activation context (a click handler) — browsers\n * block programmatic `input.click()` otherwise.\n */\nexport interface OpenFilePickerOptions {\n  /** `<input accept>` filter, e.g. `'image/*'` or `'.csv,text/csv'`. */\n  accept?: string;\n  /** Allow multi-select. Default false. */\n  multiple?: boolean;\n}\n\n/** Show the browser's file picker and resolve with what the user chose —\n *  empty when they cancel. Must be called from a user gesture. */\nexport function openFilePicker(opts: OpenFilePickerOptions = {}): Promise<File[]> {\n  return new Promise((resolve) => {\n    const input = document.createElement('input');\n    input.type = 'file';\n    input.hidden = true;\n    if (opts.accept) input.accept = opts.accept;\n    if (opts.multiple) input.multiple = true;\n    document.body.appendChild(input);\n    const finish = (files: File[]) => {\n      input.remove();\n      resolve(files);\n    };\n    input.addEventListener('change', () => finish(Array.from(input.files ?? [])), { once: true });\n    // Fired by browsers that support it when the dialog is dismissed. When\n    // unsupported, the input simply leaks until the page unloads — acceptable\n    // for a hidden element; no timer heuristics.\n    input.addEventListener('cancel', () => finish([]), { once: true });\n    input.click();\n  });\n}\n"],"mappings":";AAqBA,SAAgBA,EAAe,IAA8B,CAAC,GAAoB;CAChF,OAAO,IAAI,SAAS,MAAY;EAC9B,IAAMC,IAAQ,SAAS,cAAc,OAAO;EAK5C,AAJA,EAAM,OAAO,QACb,EAAM,SAAS,IACXC,EAAK,WAAQ,EAAM,SAASA,EAAK,SACjCA,EAAK,aAAU,EAAM,WAAW,KACpC,SAAS,KAAK,YAAYD,CAAK;EAC/B,IAAME,KAAU,MAAkB;GAEhC,AADAF,EAAM,OAAO,GACbG,EAAQC,CAAK;EACf;EAMA,AALAJ,EAAM,iBAAiB,gBAAgBE,EAAO,MAAM,KAAKF,EAAM,SAAS,CAAC,CAAC,CAAC,GAAG,EAAE,MAAM,GAAK,CAAC,GAI5FA,EAAM,iBAAiB,gBAAgBE,EAAO,CAAC,CAAC,GAAG,EAAE,MAAM,GAAK,CAAC,GACjEF,EAAM,MAAM;CACd,CAAC;AACH"}
+{"version":3,"file":"openFilePicker.js","names":["openFilePicker","input","opts","finish","resolve","files"],"sources":["../../../src/features/ingestion/openFilePicker.ts"],"sourcesContent":["/** Options for {@link openFilePicker}. */\nexport interface OpenFilePickerOptions {\n  /** `<input accept>` filter, e.g. `'image/*'` or `'.csv,text/csv'`. */\n  accept?: string;\n  /** Allow multi-select. Default false. */\n  multiple?: boolean;\n}\n\n/**\n * Show the browser's file picker and resolve with what the user chose —\n * empty when they cancel. Must be called from a user gesture (a click\n * handler): browsers block programmatic `input.click()` otherwise. Pairs\n * with `CanvasExtensionApi.ingest`:\n *\n * ```ts\n * const files = await openFilePicker({ accept: 'image/*', multiple: true });\n * canvasRef.current?.ingest(files);\n * ```\n */\nexport function openFilePicker(opts: OpenFilePickerOptions = {}): Promise<File[]> {\n  return new Promise((resolve) => {\n    const input = document.createElement('input');\n    input.type = 'file';\n    input.hidden = true;\n    if (opts.accept) input.accept = opts.accept;\n    if (opts.multiple) input.multiple = true;\n    document.body.appendChild(input);\n    const finish = (files: File[]) => {\n      input.remove();\n      resolve(files);\n    };\n    input.addEventListener('change', () => finish(Array.from(input.files ?? [])), { once: true });\n    // Where `cancel` is unsupported, the hidden input leaks until the page\n    // unloads.\n    input.addEventListener('cancel', () => finish([]), { once: true });\n    input.click();\n  });\n}\n"],"mappings":";AAmBA,SAAgBA,EAAe,IAA8B,CAAC,GAAoB;CAChF,OAAO,IAAI,SAAS,MAAY;EAC9B,IAAMC,IAAQ,SAAS,cAAc,OAAO;EAK5C,AAJA,EAAM,OAAO,QACb,EAAM,SAAS,IACXC,EAAK,WAAQ,EAAM,SAASA,EAAK,SACjCA,EAAK,aAAU,EAAM,WAAW,KACpC,SAAS,KAAK,YAAYD,CAAK;EAC/B,IAAME,KAAU,MAAkB;GAEhC,AADAF,EAAM,OAAO,GACbG,EAAQC,CAAK;EACf;EAKA,AAJAJ,EAAM,iBAAiB,gBAAgBE,EAAO,MAAM,KAAKF,EAAM,SAAS,CAAC,CAAC,CAAC,GAAG,EAAE,MAAM,GAAK,CAAC,GAG5FA,EAAM,iBAAiB,gBAAgBE,EAAO,CAAC,CAAC,GAAG,EAAE,MAAM,GAAK,CAAC,GACjEF,EAAM,MAAM;CACd,CAAC;AACH"}

package/dist/features/ingestion/placement.js

@@ -0,0 +1,16 @@
+function e(e, t, n) {
+	let r = e.viewportWorldRect(), i = e.point ?? {
+		x: r.x + r.width / 2,
+		y: r.y + r.height / 2
+	}, a = n * 24;
+	return {
+		x: i.x - t.width / 2 + a,
+		y: i.y - t.height / 2 + a,
+		width: t.width,
+		height: t.height
+	};
+}
+//#endregion
+export { e as arrivalBounds };
+
+//# sourceMappingURL=placement.js.map

package/dist/features/ingestion/placement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"placement.js","names":["arrivalBounds","view","ctx","center","offset","index","size"],"sources":["../../../src/features/ingestion/placement.ts"],"sourcesContent":["import type { IngestCtx } from './contentHandlers';\n\nconst CASCADE_OFFSET_PX = 24;\n\n/**\n * Where the kit's handlers put arriving content of a given size: centered on\n * `ctx.point` (a drop, a pointed ingest) or on the viewport (a paste), with the\n * `index`-th item of one arrival stepped down and right of the first.\n */\nexport function arrivalBounds(\n  ctx: IngestCtx,\n  size: { width: number; height: number },\n  index: number,\n): { x: number; y: number; width: number; height: number } {\n  const view = ctx.viewportWorldRect();\n  const center = ctx.point ?? { x: view.x + view.width / 2, y: view.y + view.height / 2 };\n  const offset = index * CASCADE_OFFSET_PX;\n  return {\n    x: center.x - size.width / 2 + offset,\n    y: center.y - size.height / 2 + offset,\n    width: size.width,\n    height: size.height,\n  };\n}\n"],"mappings":"AASA,SAAgBA,EACd,GACA,GACA,GACyD;CACzD,IAAMC,IAAOC,EAAI,kBAAkB,GAC7BC,IAASD,EAAI,SAAS;EAAE,GAAGD,EAAK,IAAIA,EAAK,QAAQ;EAAG,GAAGA,EAAK,IAAIA,EAAK,SAAS;CAAE,GAChFG,IAASC,IAAQ;CACvB,OAAO;EACL,GAAGF,EAAO,IAAIG,EAAK,QAAQ,IAAIF;EAC/B,GAAGD,EAAO,IAAIG,EAAK,SAAS,IAAIF;EAChC,OAAOE,EAAK;EACZ,QAAQA,EAAK;CACf;AACF"}

package/dist/features/ingestion/svgHandler.js

@@ -42,6 +42,11 @@ var o = async (e) => {
 }, s = {
 	id: "kit:svg",
 	match: (e) => i(e) || e.kind === "string" && e.mime === "text/plain" && a(e.text),
+	types: [
+		t,
+		"application/octet-stream",
+		"text/plain"
+	],
 	priority: -90,
 	handle(n, r) {
 		let i = n.flatMap((e) => e.kind === "file" ? [e.file] : []);

package/dist/features/ingestion/svgHandler.js.map

@@ -1 +1 @@
-{"version":3,"file":"svgHandler.js","names":["SVG_MIME","FALLBACK_WIDTH","FALLBACK_HEIGHT","isSvgFileItem","item","sniffSvgText","text","end","measure","url","file","img","kitSvgHandler","files","items","it","ctx","embedFilesAsImageNodes","f"],"sources":["../../../src/features/ingestion/svgHandler.ts"],"sourcesContent":["/**\n * The kit's `image/svg+xml` content handler.\n *\n * Default: a dropped SVG stays **one scene node** — the standard\n * embedded-image contract (`data.image.src` as a `data:image/svg+xml;…`\n * URI, source bytes preserved verbatim). Rendering rides the normal\n * `imageCache` path: browsers rasterize SVG in an `<img>`, so only the\n * ingest-time measurement needs special handling — Chromium's\n * `createImageBitmap` rejects raw SVG blobs, so this handler measures via\n * an `Image` element instead, falling back to 300×150 (the CSS default\n * object size) when the file declares no intrinsic dimensions.\n *\n * `<SceneCanvas ingestion={{ svg: { unpack: unpackSvgFiles } }}>` switches to\n * parsing the file into native scene nodes. The unpacker is injected (see\n * `SvgIngestOptions.unpack`) because the SVG parser lives in\n * `@weasel-js/svg`, which depends on this package.\n *\n * Registered at priority -90: ahead of `kit:image` (-100) so SVG files\n * never hit the raster measure path, still behind any consumer handler\n * (default 0).\n */\nimport type { ContentHandlerEntry, IngestCtx } from './contentHandlers';\nimport type { IngestItem } from '@weasel-js/routing';\nimport { embedFilesAsImageNodes, type Measure } from './imageHandler';\n\nexport const SVG_MIME = 'image/svg+xml';\n\n// CSS default object size — what browsers use for replaced content with no\n// intrinsic dimensions (e.g. a viewBox-only SVG in an <img>).\nconst FALLBACK_WIDTH = 300;\nconst FALLBACK_HEIGHT = 150;\n\n/**\n * True for file items that are SVG by MIME — or by `.svg` extension when\n * the source offered no usable type (an empty `File.type` normalizes to\n * `application/octet-stream` at materialization).\n */\nexport function isSvgFileItem(item: IngestItem): boolean {\n  if (item.kind !== 'file') return false;\n  if (item.mime === SVG_MIME) return true;\n  return item.mime === 'application/octet-stream' && /\\.svg$/i.test(item.file.name);\n}\n\n/**\n * Strict-prefix sniff: could this text be an SVG document? `<svg` (or an XML\n * declaration, then optional whitespace/comments/DOCTYPE, then `<svg`) must\n * open the document — no mid-document substring scans, same discipline as\n * `sniffWeaselClipboardText`. Exists because Safari drops both custom MIMEs\n * and `image/svg+xml` from async clipboard writes, leaving `text/plain` as\n * the only surviving flavor of an SVG copy.\n */\nexport function sniffSvgText(text: string): boolean {\n  let t = text.trimStart();\n  if (t.startsWith('<?xml')) {\n    const end = t.indexOf('?>');\n    if (end < 0) return false;\n    t = t.slice(end + 2);\n  }\n  for (;;) {\n    t = t.trimStart();\n    if (t.startsWith('<!--')) {\n      const end = t.indexOf('-->');\n      if (end < 0) return false;\n      t = t.slice(end + 3);\n      continue;\n    }\n    // Illustrator-style preamble: <!DOCTYPE svg PUBLIC \"...\" \"...\">. Skipping\n    // ANY doctype is safe — a non-SVG doctype's root element fails the final\n    // `<svg` check anyway. (No internal-subset handling; clipboard SVG\n    // preambles don't carry `[...]` blocks.)\n    if (/^<!doctype/i.test(t)) {\n      const end = t.indexOf('>');\n      if (end < 0) return false;\n      t = t.slice(end + 1);\n      continue;\n    }\n    break;\n  }\n  return /^<svg[\\s>/]/i.test(t);\n}\n\nconst defaultMeasure: Measure = async (file) => {\n  const url = URL.createObjectURL(file);\n  try {\n    const img = new Image();\n    img.src = url;\n    await img.decode();\n    return {\n      width: img.naturalWidth || FALLBACK_WIDTH,\n      height: img.naturalHeight || FALLBACK_HEIGHT,\n    };\n  } finally {\n    URL.revokeObjectURL(url);\n  }\n};\n\nlet measure: Measure = defaultMeasure;\n\nexport const kitSvgHandler: ContentHandlerEntry = {\n  id: 'kit:svg',\n  // Files by MIME/extension, plus the text/plain fallback flavor: SVG markup\n  // pasted as plain text (the only flavor Safari lets an SVG copy keep).\n  match: (item) =>\n    isSvgFileItem(item)\n    || (item.kind === 'string' && item.mime === 'text/plain' && sniffSvgText(item.text)),\n  priority: -90,\n  handle(items, ctx: IngestCtx) {\n    const files = items.flatMap((it) => (it.kind === 'file' ? [it.file] : []));\n    // String items (the text/plain SVG fallback flavor) enter the same file\n    // path — wrap the markup in a File so unpack/embed stays one code path.\n    // BUT skip them when the weasel-JSON handler already pasted this event's\n    // copy: draw writes weasel-JSON + SVG together, so ingesting both would\n    // double-paste. (ctx is shared per event; the weasel handler runs first.)\n    // WARNING: this read must stay before any `await` in this handle — the\n    // sync-ordering of handler microtasks is what makes the flag visible.\n    if (!ctx.consumedWeaselPayload) {\n      for (const it of items) {\n        if (it.kind === 'string') files.push(new File([it.text], 'pasted.svg', { type: SVG_MIME }));\n      }\n    }\n    if (files.length === 0) return;\n    if (ctx.svg?.unpack) return ctx.svg.unpack(files, ctx);\n    // Thunk (not the variable) so the test seam is read at call time.\n    return embedFilesAsImageNodes(files, ctx, {\n      measure: (f) => measure(f),\n      mimeOverride: SVG_MIME,\n    });\n  },\n};\n\n/** @internal test seam — override the Image-element measurer (jsdom can't\n *  decode SVG). Not part of the public barrel. */\nexport function __setSvgMeasureForTests(fn: Measure): void {\n  measure = fn;\n}\n\n/** @internal test seam — restore the default measurer. */\nexport function _resetSvgHandlerSeamsForTests(): void {\n  measure = defaultMeasure;\n}\n"],"mappings":";;AAyBA,IAAaA,IAAW,iBAIlBC,IAAiB,KACjBC,IAAkB;AAOxB,SAAgBC,EAAc,GAA2B;CAGvD,OAFIC,EAAK,SAAS,SACdA,EAAK,SAASJ,KACXI,EAAK,SAAS,8BAA8B,UAAU,KAAKA,EAAK,KAAK,IAAI,IAF/C;AAGnC;AAUA,SAAgBC,EAAa,GAAuB;CAClD,IAAI,IAAIC,EAAK,UAAU;CACvB,IAAI,EAAE,WAAW,OAAO,GAAG;EACzB,IAAMC,IAAM,EAAE,QAAQ,IAAI;EAC1B,IAAIA,IAAM,GAAG,OAAO;EACpB,IAAI,EAAE,MAAMA,IAAM,CAAC;CACrB;CACA,SAAS;EAEP,IADA,IAAI,EAAE,UAAU,GACZ,EAAE,WAAW,MAAM,GAAG;GACxB,IAAMA,IAAM,EAAE,QAAQ,KAAK;GAC3B,IAAIA,IAAM,GAAG,OAAO;GACpB,IAAI,EAAE,MAAMA,IAAM,CAAC;GACnB;EACF;EAKA,IAAI,cAAc,KAAK,CAAC,GAAG;GACzB,IAAMA,IAAM,EAAE,QAAQ,GAAG;GACzB,IAAIA,IAAM,GAAG,OAAO;GACpB,IAAI,EAAE,MAAMA,IAAM,CAAC;GACnB;EACF;EACA;CACF;CACA,OAAO,eAAe,KAAK,CAAC;AAC9B;AAiBA,IAAIC,IAAmB,OAfgB,MAAS;CAC9C,IAAMC,IAAM,IAAI,gBAAgBC,CAAI;CACpC,IAAI;EACF,IAAMC,IAAM,IAAI,MAAM;EAGtB,OAFA,EAAI,MAAMF,GACV,MAAME,EAAI,OAAO,GACV;GACL,OAAOA,EAAI,gBAAgBV;GAC3B,QAAQU,EAAI,iBAAiBT;EAC/B;CACF,UAAU;EACR,IAAI,gBAAgBO,CAAG;CACzB;AACF,GAIaG,IAAqC;CAChD,IAAI;CAGJ,QAAQ,MACNT,EAAcC,CAAI,KACdA,EAAK,SAAS,YAAYA,EAAK,SAAS,gBAAgBC,EAAaD,EAAK,IAAI;CACpF,UAAU;CACV,OAAO,GAAO,GAAgB;EAC5B,IAAMS,IAAQC,EAAM,SAAS,MAAQC,EAAG,SAAS,SAAS,CAACA,EAAG,IAAI,IAAI,CAAC,CAAE;EAQzE,IAAI,CAACC,EAAI,uBACF,KAAA,IAAMD,KAAMD,GACf,AAAIC,EAAG,SAAS,YAAUF,EAAM,KAAK,IAAI,KAAK,CAACE,EAAG,IAAI,GAAG,cAAc,EAAE,MAAMf,EAAS,CAAC,CAAC;EAG9F,IAAIa,EAAM,WAAW,GAGrB,OAFIG,EAAI,KAAK,SAAeA,EAAI,IAAI,OAAOH,GAAOG,CAAG,IAE9CC,EAAuBJ,GAAOG,GAAK;GACxC,UAAU,MAAMR,EAAQU,CAAC;GACzB,cAAclB;EAChB,CAAC;CACH;AACF"}
+{"version":3,"file":"svgHandler.js","names":["SVG_MIME","FALLBACK_WIDTH","FALLBACK_HEIGHT","isSvgFileItem","item","sniffSvgText","text","end","measure","url","file","img","kitSvgHandler","files","items","it","ctx","embedFilesAsImageNodes","f"],"sources":["../../../src/features/ingestion/svgHandler.ts"],"sourcesContent":["/**\n * The kit's `image/svg+xml` content handler.\n *\n * Default: a dropped SVG stays **one scene node** — an embedded image\n * (`data.image.src` as a `data:image/svg+xml;…` URI, source bytes preserved\n * verbatim). Chromium's `createImageBitmap` rejects raw SVG blobs, so this\n * handler measures via an `Image` element instead, falling back to 300×150\n * (the CSS default object size) when the file declares no intrinsic\n * dimensions.\n *\n * `<SceneCanvas ingestion={{ svg: { unpack: unpackSvgFiles } }}>` switches to\n * parsing the file into native scene nodes. The unpacker is injected because\n * the SVG parser lives in `@weasel-js/svg`, which depends on this package.\n *\n * Registered at priority -90: ahead of `kit:image` (-100) so SVG files\n * never hit the raster measure path, still behind any consumer handler\n * (default 0).\n */\nimport type { ContentHandlerEntry, IngestCtx } from './contentHandlers';\nimport type { IngestItem } from '@weasel-js/routing';\nimport { embedFilesAsImageNodes, type Measure } from './imageHandler';\n\nexport const SVG_MIME = 'image/svg+xml';\n\n// CSS default object size — what browsers use for replaced content with no\n// intrinsic dimensions (e.g. a viewBox-only SVG in an <img>).\nconst FALLBACK_WIDTH = 300;\nconst FALLBACK_HEIGHT = 150;\n\n/**\n * True for file items that are SVG by MIME — or by `.svg` extension when\n * the source offered no usable type (an empty `File.type` normalizes to\n * `application/octet-stream` at materialization).\n */\nexport function isSvgFileItem(item: IngestItem): boolean {\n  if (item.kind !== 'file') return false;\n  if (item.mime === SVG_MIME) return true;\n  return item.mime === 'application/octet-stream' && /\\.svg$/i.test(item.file.name);\n}\n\n/**\n * Strict-prefix sniff: could this text be an SVG document? `<svg` (or an XML\n * declaration, then optional whitespace/comments/DOCTYPE, then `<svg`) must\n * open the document — no mid-document substring scans. Exists because Safari drops both custom MIMEs\n * and `image/svg+xml` from async clipboard writes, leaving `text/plain` as\n * the only surviving flavor of an SVG copy.\n */\nexport function sniffSvgText(text: string): boolean {\n  let t = text.trimStart();\n  if (t.startsWith('<?xml')) {\n    const end = t.indexOf('?>');\n    if (end < 0) return false;\n    t = t.slice(end + 2);\n  }\n  for (;;) {\n    t = t.trimStart();\n    if (t.startsWith('<!--')) {\n      const end = t.indexOf('-->');\n      if (end < 0) return false;\n      t = t.slice(end + 3);\n      continue;\n    }\n    // Skipping ANY doctype is safe — a non-SVG doctype's root element fails\n    // the final `<svg` check anyway. No internal-subset (`[...]`) handling.\n    if (/^<!doctype/i.test(t)) {\n      const end = t.indexOf('>');\n      if (end < 0) return false;\n      t = t.slice(end + 1);\n      continue;\n    }\n    break;\n  }\n  return /^<svg[\\s>/]/i.test(t);\n}\n\nconst defaultMeasure: Measure = async (file) => {\n  const url = URL.createObjectURL(file);\n  try {\n    const img = new Image();\n    img.src = url;\n    await img.decode();\n    return {\n      width: img.naturalWidth || FALLBACK_WIDTH,\n      height: img.naturalHeight || FALLBACK_HEIGHT,\n    };\n  } finally {\n    URL.revokeObjectURL(url);\n  }\n};\n\nlet measure: Measure = defaultMeasure;\n\nexport const kitSvgHandler: ContentHandlerEntry = {\n  id: 'kit:svg',\n  // Files by MIME/extension, plus the text/plain fallback flavor: SVG markup\n  // pasted as plain text (the only flavor Safari lets an SVG copy keep).\n  match: (item) =>\n    isSvgFileItem(item)\n    || (item.kind === 'string' && item.mime === 'text/plain' && sniffSvgText(item.text)),\n  types: [SVG_MIME, 'application/octet-stream', 'text/plain'],\n  priority: -90,\n  handle(items, ctx: IngestCtx) {\n    const files = items.flatMap((it) => (it.kind === 'file' ? [it.file] : []));\n    // String items are skipped when the weasel-JSON handler already pasted\n    // this event's copy: ingesting both flavors would double-paste.\n    // WARNING: this read must stay before any `await` in this handle — the\n    // sync-ordering of handler microtasks is what makes the flag visible.\n    if (!ctx.consumedWeaselPayload) {\n      for (const it of items) {\n        if (it.kind === 'string') files.push(new File([it.text], 'pasted.svg', { type: SVG_MIME }));\n      }\n    }\n    if (files.length === 0) return;\n    if (ctx.svg?.unpack) return ctx.svg.unpack(files, ctx);\n    // Thunk (not the variable) so the test seam is read at call time.\n    return embedFilesAsImageNodes(files, ctx, {\n      measure: (f) => measure(f),\n      mimeOverride: SVG_MIME,\n    });\n  },\n};\n\n/** @internal test seam — override the Image-element measurer (jsdom can't\n *  decode SVG). Not part of the public barrel. */\nexport function __setSvgMeasureForTests(fn: Measure): void {\n  measure = fn;\n}\n\n/** @internal test seam — restore the default measurer. */\nexport function _resetSvgHandlerSeamsForTests(): void {\n  measure = defaultMeasure;\n}\n"],"mappings":";;AAsBA,IAAaA,IAAW,iBAIlBC,IAAiB,KACjBC,IAAkB;AAOxB,SAAgBC,EAAc,GAA2B;CAGvD,OAFIC,EAAK,SAAS,SACdA,EAAK,SAASJ,KACXI,EAAK,SAAS,8BAA8B,UAAU,KAAKA,EAAK,KAAK,IAAI,IAF/C;AAGnC;AASA,SAAgBC,EAAa,GAAuB;CAClD,IAAI,IAAIC,EAAK,UAAU;CACvB,IAAI,EAAE,WAAW,OAAO,GAAG;EACzB,IAAMC,IAAM,EAAE,QAAQ,IAAI;EAC1B,IAAIA,IAAM,GAAG,OAAO;EACpB,IAAI,EAAE,MAAMA,IAAM,CAAC;CACrB;CACA,SAAS;EAEP,IADA,IAAI,EAAE,UAAU,GACZ,EAAE,WAAW,MAAM,GAAG;GACxB,IAAMA,IAAM,EAAE,QAAQ,KAAK;GAC3B,IAAIA,IAAM,GAAG,OAAO;GACpB,IAAI,EAAE,MAAMA,IAAM,CAAC;GACnB;EACF;EAGA,IAAI,cAAc,KAAK,CAAC,GAAG;GACzB,IAAMA,IAAM,EAAE,QAAQ,GAAG;GACzB,IAAIA,IAAM,GAAG,OAAO;GACpB,IAAI,EAAE,MAAMA,IAAM,CAAC;GACnB;EACF;EACA;CACF;CACA,OAAO,eAAe,KAAK,CAAC;AAC9B;AAiBA,IAAIC,IAAmB,OAfgB,MAAS;CAC9C,IAAMC,IAAM,IAAI,gBAAgBC,CAAI;CACpC,IAAI;EACF,IAAMC,IAAM,IAAI,MAAM;EAGtB,OAFA,EAAI,MAAMF,GACV,MAAME,EAAI,OAAO,GACV;GACL,OAAOA,EAAI,gBAAgBV;GAC3B,QAAQU,EAAI,iBAAiBT;EAC/B;CACF,UAAU;EACR,IAAI,gBAAgBO,CAAG;CACzB;AACF,GAIaG,IAAqC;CAChD,IAAI;CAGJ,QAAQ,MACNT,EAAcC,CAAI,KACdA,EAAK,SAAS,YAAYA,EAAK,SAAS,gBAAgBC,EAAaD,EAAK,IAAI;CACpF,OAAO;EAACJ;EAAU;EAA4B;CAAY;CAC1D,UAAU;CACV,OAAO,GAAO,GAAgB;EAC5B,IAAMa,IAAQC,EAAM,SAAS,MAAQC,EAAG,SAAS,SAAS,CAACA,EAAG,IAAI,IAAI,CAAC,CAAE;EAKzE,IAAI,CAACC,EAAI,uBACF,KAAA,IAAMD,KAAMD,GACf,AAAIC,EAAG,SAAS,YAAUF,EAAM,KAAK,IAAI,KAAK,CAACE,EAAG,IAAI,GAAG,cAAc,EAAE,MAAMf,EAAS,CAAC,CAAC;EAG9F,IAAIa,EAAM,WAAW,GAGrB,OAFIG,EAAI,KAAK,SAAeA,EAAI,IAAI,OAAOH,GAAOG,CAAG,IAE9CC,EAAuBJ,GAAOG,GAAK;GACxC,UAAU,MAAMR,EAAQU,CAAC;GACzB,cAAclB;EAChB,CAAC;CACH;AACF"}

package/dist/features/ingestion/textHandler.js

@@ -0,0 +1,28 @@
+import { arrivalBounds as e } from "./placement.js";
+import { measureTextBounds as t } from "@weasel-js/text";
+//#region src/features/ingestion/textHandler.ts
+function n(n = {}) {
+	let r = n.measure ?? ((e) => t(e));
+	return {
+		id: "kit:text",
+		match: (e) => e.kind === "string" && e.mime === "text/plain",
+		types: ["text/plain"],
+		priority: -110,
+		handle(t, n) {
+			let i = 0;
+			for (let a of t) {
+				if (a.kind !== "string") continue;
+				let t = a.text.replace(/\r\n?/g, "\n").replace(/\n+$/, "");
+				t.trim() !== "" && (n.insert.commit(e(n, r(t), i), {
+					kind: "text",
+					text: t
+				}), i++);
+			}
+		}
+	};
+}
+var r = n();
+//#endregion
+export { n as createTextHandler, r as kitTextHandler };
+
+//# sourceMappingURL=textHandler.js.map

package/dist/features/ingestion/textHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textHandler.js","names":["createTextHandler","measure","opts","measureTextBounds","text","item","index","items","ctx","arrivalBounds","kitTextHandler"],"sources":["../../../src/features/ingestion/textHandler.ts"],"sourcesContent":["/**\n * The kit's `text/plain` content handler: a pasted or dropped string becomes\n * a text node. Not registered by default; a canvas takes it through\n * `ingestion.handlers`.\n *\n * The node's box is the string's own laid-out size at the default text style,\n * so it holds the text exactly and wraps nowhere the string does not break.\n * Placement is the image handler's: on the point, or centered in the viewport.\n *\n * Priority -110, below every kit handler, so SVG markup and a copied node\n * payload arriving as plain text go to the handlers that read them.\n */\nimport { measureTextBounds } from '@weasel-js/text';\nimport type { IngestItem } from '@weasel-js/routing';\nimport type { ContentHandlerEntry, IngestCtx } from './contentHandlers';\nimport { arrivalBounds } from './placement';\n\n/** Options for {@link createTextHandler}. */\nexport interface TextHandlerOptions {\n  /** Size of a string's layout box in world units. Default\n   *  `measureTextBounds`, which reads the registered font. */\n  measure?: (text: string) => { width: number; height: number };\n}\n\n/** Build the plain-text content handler; {@link kitTextHandler} is the one\n *  with the default measurer. */\nexport function createTextHandler(opts: TextHandlerOptions = {}): ContentHandlerEntry {\n  const measure = opts.measure ?? ((text: string) => measureTextBounds(text));\n  return {\n    id: 'kit:text',\n    match: (item: IngestItem) => item.kind === 'string' && item.mime === 'text/plain',\n    types: ['text/plain'],\n    priority: -110,\n    handle(items, ctx: IngestCtx) {\n      let index = 0;\n      for (const item of items) {\n        if (item.kind !== 'string') continue;\n        const text = item.text.replace(/\\r\\n?/g, '\\n').replace(/\\n+$/, '');\n        if (text.trim() === '') continue;\n        ctx.insert.commit(arrivalBounds(ctx, measure(text), index), { kind: 'text', text });\n        index++;\n      }\n    },\n  };\n}\n\n/**\n * Turns pasted or dropped plain text into a text node sized to the string. Registered nowhere by\n * default: a canvas opts in with `ingestion={{ handlers: [kitTextHandler] }}`.\n */\nexport const kitTextHandler: ContentHandlerEntry = createTextHandler();\n"],"mappings":";;;AA0BA,SAAgBA,EAAkB,IAA2B,CAAC,GAAwB;CACpF,IAAMC,IAAUC,EAAK,aAAa,MAAiBC,EAAkBC,CAAI;CACzE,OAAO;EACL,IAAI;EACJ,QAAQ,MAAqBC,EAAK,SAAS,YAAYA,EAAK,SAAS;EACrE,OAAO,CAAC,YAAY;EACpB,UAAU;EACV,OAAO,GAAO,GAAgB;GAC5B,IAAIC,IAAQ;GACZ,KAAK,IAAMD,KAAQE,GAAO;IACxB,IAAIF,EAAK,SAAS,UAAU;IAC5B,IAAMD,IAAOC,EAAK,KAAK,QAAQ,UAAU,IAAI,CAAC,CAAC,QAAQ,QAAQ,EAAE;IACjE,AAAID,EAAK,KAAK,MAAM,OACpBI,EAAI,OAAO,OAAOC,EAAcD,GAAKP,EAAQG,CAAI,GAAGE,CAAK,GAAG;KAAE,MAAM;KAAQ;IAAK,CAAC,GAClF;GACF;EACF;CACF;AACF;AAMA,IAAaI,IAAsCV,EAAkB"}

package/dist/features/ingestion/useCanvasIngestion.js

@@ -0,0 +1,48 @@
+import { dwarn as e } from "../../debug/flag.js";
+import { registerContentHandler as t } from "./contentHandlers.js";
+import { acquireKitContentHandlers as n } from "./registerKitHandlers.js";
+import { useCallback as r, useEffect as i, useMemo as a } from "react";
+import { useLatest as o } from "@weasel-js/react";
+import { itemsFromFiles as s } from "@weasel-js/routing";
+//#region src/features/ingestion/useCanvasIngestion.ts
+function c(c, l, u) {
+	let d = u?.handlers;
+	i(() => {
+		let e = [n()];
+		for (let n of d ?? []) e.push(t(n));
+		return () => e.forEach((e) => e());
+	}, [d]);
+	let f = u?.clipboard?.reviver, p = u?.clipboard?.enabled !== !1, m = o(u?.clipboard?.onOmitted), h = a(() => {
+		if (p && c.commitPaste) return {
+			adapter: c,
+			...f ? { reviver: f } : {},
+			onOmitted: (e) => m.current?.(e)
+		};
+	}, [
+		c,
+		p,
+		f,
+		m
+	]), g = o(l);
+	return {
+		ingest: r((t, n) => {
+			let r = t.map((e) => e instanceof File ? s([e])[0] : e);
+			if (r.length === 0) return !1;
+			let i = g.current();
+			if (!i) return e("ingest", "CanvasExtensionApi.ingest called before the action registry mounted — call ignored. Defer to an effect or event handler."), !1;
+			let a = {
+				items: r,
+				...n ? {
+					worldX: n.x,
+					worldY: n.y
+				} : {}
+			}, o = i.trigger("ingest", a);
+			return o || e("ingest", "CanvasExtensionApi.ingest ran nothing: this canvas has no `ingest` action. Add `ingest` to `features`."), o;
+		}, [g]),
+		clipboard: h
+	};
+}
+//#endregion
+export { c as useCanvasIngestion };
+
+//# sourceMappingURL=useCanvasIngestion.js.map