@ai-matrx/summon 0.1.16 → 0.1.18

package/dist/chunk-server-H7NUWPEM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/open/ids.ts","../src/handles/slot.ts","../src/open/handleEntries.ts"],"sourcesContent":["/** A fresh handle id: `crypto.randomUUID` when present, else a v4 UUID from `getRandomValues`. */\nexport function newHandleId(): string {\n  const c: Crypto | undefined = typeof globalThis.crypto === \"undefined\" ? undefined : globalThis.crypto;\n  if (c && typeof c.randomUUID === \"function\") return c.randomUUID();\n  const bytes = new Uint8Array(16);\n  if (c && typeof c.getRandomValues === \"function\") {\n    c.getRandomValues(bytes);\n  } else {\n    for (let i = 0; i < 16; i += 1) bytes[i] = Math.floor(Math.random() * 256);\n  }\n  bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x40;\n  bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80;\n  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, \"0\")).join(\"\");\n  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;\n}\n","/** The global slot that holds the handles registry (one registry per realm, whatever the bundling). */\nexport const HANDLES_SLOT = \"ai-matrx.summon.handles\";\n","// The handles registry's STATE and its insert/remove path, without the registry's verbs (trigger,\n// subscribe, requests, channels). A boot-time opener that only needs an id NOW — register a\n// callback, a payload group, an object handle; drop it on close — writes through here and never\n// puts `@ai-matrx/summon/handles` in first load; whoever later triggers or reads loads the full\n// registry, which works on the same global slot through these same functions (one removal path).\nimport { globalSlot } from \"@ai-matrx/kit/global-slot\";\nimport { HANDLES_SLOT } from \"../handles/slot\";\nimport { newHandleId } from \"./ids\";\n\n/** A registry slot: a callback (invoked by triggers) or an object handle (only ever read). */\nexport type HandleEntrySlot = ((...args: never[]) => unknown) | object;\n\n/** @internal A registry entry (the handles section adds `listeners`). */\nexport interface HandleEntry {\n  callback: HandleEntrySlot;\n  context?: Record<string, unknown>;\n  groupId?: string;\n  owner?: string;\n  listeners?: Array<(...args: never[]) => unknown>;\n  /** Runs once when the entry leaves the registry for any reason (requests reject here). */\n  onRemove?: () => void;\n}\n\n/** @internal The registry state in its global slot (one per realm, whatever the bundling). */\nexport interface HandlesState {\n  readonly callbacks: Map<string, HandleEntry>;\n  readonly groups: Map<string, Set<string>>;\n  readonly owners: Map<string, Set<string>>;\n  readonly registryListeners: Set<() => void>;\n}\n\nexport interface HandleEntryOptions {\n  /** A fixed id (default: a fresh `newHandleId()`); an existing entry with it is replaced. */\n  id?: string;\n  context?: Record<string, unknown>;\n  /** Join (or start) this group; `removeHandleGroup` drops every member. */\n  groupId?: string;\n  /** The InstanceKey (`overlayId:instanceId`) that owns this entry; disposed when it closes. */\n  owner?: string;\n  onRemove?: () => void;\n}\n\n/** @internal */\nexport const handlesState = (): HandlesState =>\n  globalSlot<HandlesState>(HANDLES_SLOT, () => ({\n    callbacks: new Map(),\n    groups: new Map(),\n    owners: new Map(),\n    registryListeners: new Set(),\n  }));\n\n/** @internal */\nexport function notifyHandlesRegistry(): void {\n  for (const listener of [...handlesState().registryListeners]) listener();\n}\n\n/**\n * The one removal path. Reads the entry BEFORE deleting it so group and owner membership shrink,\n * then runs the entry's removal hook.\n */\nexport function deleteHandleEntry(id: string, notify = true): void {\n  const s = handlesState();\n  const entry = s.callbacks.get(id);\n  if (!entry) return;\n  s.callbacks.delete(id);\n  if (entry.groupId !== undefined) {\n    const group = s.groups.get(entry.groupId);\n    group?.delete(id);\n    if (group?.size === 0) s.groups.delete(entry.groupId);\n  }\n  if (entry.owner !== undefined) {\n    const owned = s.owners.get(entry.owner);\n    owned?.delete(id);\n    if (owned?.size === 0) s.owners.delete(entry.owner);\n  }\n  if (notify) notifyHandlesRegistry();\n  entry.onRemove?.();\n}\n\n/** Register a callback or object handle NOW (no registry load); returns its id. */\nexport function registerHandleEntry(slot: HandleEntrySlot, options: HandleEntryOptions = {}): string {\n  const s = handlesState();\n  const id = options.id ?? newHandleId();\n  if (s.callbacks.has(id)) deleteHandleEntry(id, false);\n  const entry: HandleEntry = { callback: slot };\n  if (options.context !== undefined) entry.context = options.context;\n  if (options.groupId !== undefined) entry.groupId = options.groupId;\n  if (options.owner !== undefined) entry.owner = options.owner;\n  if (options.onRemove !== undefined) entry.onRemove = options.onRemove;\n  s.callbacks.set(id, entry);\n  if (options.groupId !== undefined) {\n    const group = s.groups.get(options.groupId) ?? new Set<string>();\n    group.add(id);\n    s.groups.set(options.groupId, group);\n  }\n  if (options.owner !== undefined) {\n    const owned = s.owners.get(options.owner) ?? new Set<string>();\n    owned.add(id);\n    s.owners.set(options.owner, owned);\n  }\n  notifyHandlesRegistry();\n  return id;\n}\n\n/** `callbackManager.unregister(id)` without loading the registry. */\nexport function unregisterHandleEntry(id: string): void {\n  deleteHandleEntry(id, true);\n}\n\n/** `callbackManager.removeGroup(groupId)` without loading the registry. */\nexport function removeHandleGroup(groupId: string): void {\n  const s = handlesState();\n  const group = s.groups.get(groupId);\n  if (!group) return;\n  s.groups.delete(groupId);\n  for (const id of [...group]) deleteHandleEntry(id, false);\n  notifyHandlesRegistry();\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-server-WP7NOTZQ.js

@@ -0,0 +1,208 @@
+import {
+  deleteHandleEntry,
+  handlesState,
+  newHandleId,
+  notifyHandlesRegistry,
+  registerHandleEntry,
+  removeHandleGroup
+} from "./chunk-server-H7NUWPEM.js";
+
+// src/handles/callbackManager.ts
+var handlesState2 = () => handlesState();
+function invoke(slot, data, context) {
+  if (typeof slot !== "function") return void 0;
+  return slot(data, context);
+}
+function invokeListener(listener, data, context) {
+  return listener(data, context);
+}
+var CallbackManager = class {
+  get s() {
+    return handlesState2();
+  }
+  /**
+   * Observe the registry itself: `listener` runs after any entry is added or removed. This lets a
+   * view that resolves ids with `get` re-render when an id goes away (`useSyncExternalStore`).
+   */
+  subscribeToRegistry(listener) {
+    const listeners = this.s.registryListeners;
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+  notifyRegistry() {
+    notifyHandlesRegistry();
+  }
+  /** Register a callback; returns its id. */
+  register(callback) {
+    return this.registerEntry(callback, {});
+  }
+  /** Register with optional context, group and owner. */
+  registerWithContext(callback, options = {}) {
+    return this.registerEntry(callback, options);
+  }
+  /** @internal The one insertion path (typed helpers pass a fixed id and a removal hook). */
+  registerEntry(slot, options) {
+    return registerHandleEntry(slot, options);
+  }
+  /** Subscribe to results for a callback id. */
+  subscribe(callbackId, listener) {
+    const entry = this.s.callbacks.get(callbackId);
+    if (!entry) return false;
+    (entry.listeners ??= []).push(listener);
+    return true;
+  }
+  /** Unsubscribe a listener from a callback id. */
+  unsubscribe(callbackId, listener) {
+    const entry = this.s.callbacks.get(callbackId);
+    if (!entry || !entry.listeners) return false;
+    const index = entry.listeners.indexOf(listener);
+    if (index === -1) return false;
+    entry.listeners.splice(index, 1);
+    return true;
+  }
+  /** Run a callback once, notify its listeners, then remove it. */
+  trigger(callbackId, data) {
+    const entry = this.s.callbacks.get(callbackId);
+    if (!entry) return;
+    void invoke(entry.callback, data);
+    if (entry.listeners && entry.listeners.length > 0) {
+      for (const listener of [...entry.listeners]) void invokeListener(listener, data);
+    }
+    this.deleteEntry(callbackId, true);
+  }
+  /** Trigger with merged context and progress; removes unless `removeAfterTrigger: false`. */
+  triggerWithContext(callbackId, data, options) {
+    const entry = this.s.callbacks.get(callbackId);
+    if (!entry) return;
+    const mergedContext = {
+      ...entry.context,
+      ...options?.context,
+      ...options?.progress && { progress: options.progress }
+    };
+    void invoke(entry.callback, data, mergedContext);
+    if (entry.listeners && entry.listeners.length > 0) {
+      for (const listener of [...entry.listeners]) void invokeListener(listener, data, mergedContext);
+    }
+    if (options?.removeAfterTrigger !== false) this.deleteEntry(callbackId, true);
+  }
+  /** Trigger every callback in a group. */
+  triggerGroup(groupId, data, options) {
+    const group = this.s.groups.get(groupId);
+    if (!group) return;
+    for (const callbackId of [...group]) this.triggerWithContext(callbackId, data, options);
+    if (options?.removeAfterTrigger !== false) this.s.groups.delete(groupId);
+  }
+  /**
+   * Run the one durable command registered for a group. A command is retained on rejection so its
+   * caller can retry, and is removed only after its promise settles successfully.
+   */
+  async triggerGroupCommand(groupId, data, options) {
+    const group = this.s.groups.get(groupId);
+    const callbackIds = group ? [...group] : [];
+    const callbackId = callbackIds[0];
+    if (callbackIds.length !== 1 || callbackId === void 0) {
+      throw new Error(`Expected exactly one command callback for group "${groupId}", found ${callbackIds.length}`);
+    }
+    const entry = this.s.callbacks.get(callbackId);
+    if (!entry) throw new Error(`Command callback "${callbackId}" is no longer available`);
+    const mergedContext = { ...entry.context, ...options?.context };
+    await invoke(entry.callback, data, mergedContext);
+    for (const listener of entry.listeners ?? []) {
+      try {
+        await invokeListener(listener, data, mergedContext);
+      } catch (error) {
+        console.error("[overlays/handles] command observer failed", error);
+      }
+    }
+    if (options?.removeAfterSuccess !== false) {
+      this.deleteEntry(callbackId, true);
+      this.s.groups.delete(groupId);
+    }
+  }
+  /** Report progress to a callback (or every callback of a group) without removing it. */
+  updateProgress(id, progress, options) {
+    const progressInfo = { progress, status: options?.status || "running" };
+    if (options?.error !== void 0) progressInfo.error = options.error;
+    if (options?.groupId) {
+      this.triggerGroup(id, null, { progress: progressInfo, removeAfterTrigger: false });
+    } else {
+      this.triggerWithContext(id, null, { progress: progressInfo, removeAfterTrigger: false });
+    }
+  }
+  /** Create a new, empty group and return its id. */
+  createGroup() {
+    const groupId = newHandleId();
+    this.s.groups.set(groupId, /* @__PURE__ */ new Set());
+    return groupId;
+  }
+  /** Remove one entry (and its group/owner membership). */
+  remove(callbackId) {
+    this.deleteEntry(callbackId, true);
+  }
+  /** Alias of `remove` — the preferred name when unregistering a handle on unmount. */
+  unregister(callbackId) {
+    this.remove(callbackId);
+  }
+  /** The stored callback or object handle for an id, without invoking it. */
+  get(callbackId) {
+    return this.s.callbacks.get(callbackId)?.callback;
+  }
+  /** True when the id is registered. */
+  has(callbackId) {
+    return this.s.callbacks.has(callbackId);
+  }
+  /**
+   * Register an object handle (a widget handle, an editor API, …). The object occupies the slot;
+   * it is never invoked by `trigger`, only retrieved with `get`.
+   */
+  registerWidgetHandle(handle, options = {}) {
+    return this.registerEntry(handle, options.owner === void 0 ? {} : { owner: options.owner });
+  }
+  /** Remove a group and all its callbacks. */
+  removeGroup(groupId) {
+    removeHandleGroup(groupId);
+  }
+  /** Remove everything registered with `owner` (an InstanceKey). Returns how many were removed. */
+  disposeOwner(owner) {
+    const s = this.s;
+    const owned = s.owners.get(owner);
+    if (!owned) return 0;
+    s.owners.delete(owner);
+    const ids = [...owned];
+    for (const callbackId of ids) this.deleteEntry(callbackId, false);
+    if (ids.length > 0) this.notifyRegistry();
+    return ids.length;
+  }
+  /** Ids currently owned by `owner`. */
+  ownedBy(owner) {
+    return [...this.s.owners.get(owner) ?? []];
+  }
+  /** The member ids of a group (empty when unknown). */
+  groupMembers(groupId) {
+    return [...this.s.groups.get(groupId) ?? []];
+  }
+  /** Total registered entries (diagnostics, leak tests). */
+  size() {
+    return this.s.callbacks.size;
+  }
+  /**
+   * The one removal path. Reads the entry BEFORE deleting it so group and owner membership shrink
+   * (the old `removeFromGroups`-after-delete bug), then runs the entry's removal hook.
+   */
+  deleteEntry(callbackId, notify) {
+    deleteHandleEntry(callbackId, notify);
+  }
+};
+var callbackManager = new CallbackManager();
+function disposeOwner(owner) {
+  return callbackManager.disposeOwner(owner);
+}
+
+export {
+  CallbackManager,
+  callbackManager,
+  disposeOwner
+};
+//# sourceMappingURL=chunk-server-WP7NOTZQ.js.map

package/dist/chunk-server-WP7NOTZQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/handles/callbackManager.ts"],"sourcesContent":["/**\n * The handles registry — everything that cannot travel through Redux (callbacks, event channels,\n * one-shot requests, imperative object handles) lives here under a string id; only the id goes\n * into overlay open data.\n *\n * Successor of `@ai-matrx/chat` `utils/callbackManager.ts` with the SAME public verbs and types, so\n * moving a caller is an import-path swap. Changes (CHANGELOG 0.1.0):\n *   1. State lives in the global slot \"ai-matrx.summon.handles\", never in module scope: a\n *      duplicated module graph (ESM + CJS, unsplit bundles, two packages) sees one registry.\n *   2. Removal bug fixed: `trigger` / `triggerWithContext` / `remove` deleted the entry BEFORE\n *      `removeFromGroups` read it, so group membership never shrank and emptied groups were never\n *      dropped. Removal now reads the entry first, in one place (`deleteEntry`).\n *   3. Owner scoping: `registerWithContext(cb, { owner })` (an InstanceKey `overlayId:instanceId`)\n *      ties the entry to an open overlay instance; `disposeOwner(owner)` removes everything it\n *      owns. The overlays close middleware calls it, so no opener disposes by hand.\n *   4. The object slot is handle-agnostic: `registerWidgetHandle<H extends object>(handle)` stores\n *      any object (no chat `WidgetHandle` import).\n *   5. Ids come from `crypto.randomUUID` (no `uuid` dependency), with a fallback for insecure\n *      contexts where `randomUUID` is absent.\n *\n * Framework-free: no React, no Redux.\n */\nimport { newHandleId } from \"./ids\";\nimport { HANDLES_SLOT } from \"./slot\";\nimport {\n  deleteHandleEntry,\n  handlesState as sharedHandlesState,\n  notifyHandlesRegistry,\n  registerHandleEntry,\n  removeHandleGroup,\n  type HandlesState as SharedHandlesState,\n} from \"../open/handleEntries\";\n\nexport type CallbackContext = Record<string, unknown>;\n\nexport interface ProgressInfo {\n  progress?: number;\n  status?: \"pending\" | \"running\" | \"completed\" | \"error\";\n  error?: Error;\n}\n\nexport type Callback<T = unknown, C extends CallbackContext = CallbackContext> = (\n  data: T,\n  context?: C,\n) => void | Promise<void>;\n\n/** What an entry's slot holds: a callback, or an object handle retrieved with `get`. */\nexport type HandleSlot = Callback<never, never> | object;\n\nexport interface RegisterOptions<C extends CallbackContext = CallbackContext> {\n  context?: C;\n  groupId?: string;\n  /** The InstanceKey (`overlayId:instanceId`) that owns this entry; disposed when it closes. */\n  owner?: string;\n}\n\nexport interface TriggerOptions<C extends CallbackContext = CallbackContext> {\n  context?: C;\n  progress?: ProgressInfo;\n  removeAfterTrigger?: boolean;\n}\n\n/** A registry entry. `callback` is the heterogeneous slot (function or object handle). */\ninterface CallbackEntry {\n  callback: HandleSlot;\n  context?: CallbackContext;\n  groupId?: string;\n  owner?: string;\n  listeners?: Array<Callback<never, never>>;\n  /** Runs once when the entry leaves the registry for any reason (requests reject here). */\n  onRemove?: () => void;\n}\n\ninterface HandlesState {\n  readonly callbacks: Map<string, CallbackEntry>;\n  readonly groups: Map<string, Set<string>>;\n  readonly owners: Map<string, Set<string>>;\n  readonly registryListeners: Set<() => void>;\n}\n\nexport { HANDLES_SLOT };\n\n// State, insertion and removal are the light path on `./open` (`open/handleEntries.ts`), so a\n// boot-time registrant and this registry share one slot and one removal path.\nconst handlesState = (): HandlesState => sharedHandlesState() as SharedHandlesState as HandlesState;\n\n/** Invoke a slot as a callback (a function slot only; object handles are never invoked). */\nfunction invoke(slot: HandleSlot, data: unknown, context?: CallbackContext): void | Promise<void> {\n  if (typeof slot !== \"function\") return undefined;\n  return (slot as Callback<unknown, CallbackContext>)(data, context);\n}\n\nfunction invokeListener(listener: Callback<never, never>, data: unknown, context?: CallbackContext): void | Promise<void> {\n  return (listener as Callback<unknown, CallbackContext>)(data, context);\n}\n\n/** Internal registration options beyond the public ones (used by the typed helpers). */\nexport interface InternalRegisterOptions extends RegisterOptions {\n  id?: string;\n  onRemove?: () => void;\n}\n\nexport class CallbackManager {\n  private get s(): HandlesState {\n    return handlesState();\n  }\n\n  /**\n   * Observe the registry itself: `listener` runs after any entry is added or removed. This lets a\n   * view that resolves ids with `get` re-render when an id goes away (`useSyncExternalStore`).\n   */\n  subscribeToRegistry(listener: () => void): () => void {\n    const listeners = this.s.registryListeners;\n    listeners.add(listener);\n    return () => {\n      listeners.delete(listener);\n    };\n  }\n\n  private notifyRegistry(): void {\n    notifyHandlesRegistry();\n  }\n\n  /** Register a callback; returns its id. */\n  register<T>(callback: Callback<T>): string {\n    return this.registerEntry(callback as HandleSlot, {});\n  }\n\n  /** Register with optional context, group and owner. */\n  registerWithContext<T, C extends CallbackContext = CallbackContext>(\n    callback: Callback<T, C>,\n    options: RegisterOptions<C> = {},\n  ): string {\n    return this.registerEntry(callback as HandleSlot, options);\n  }\n\n  /** @internal The one insertion path (typed helpers pass a fixed id and a removal hook). */\n  registerEntry(slot: HandleSlot, options: InternalRegisterOptions): string {\n    return registerHandleEntry(slot, options);\n  }\n\n  /** Subscribe to results for a callback id. */\n  subscribe<T, C extends CallbackContext = CallbackContext>(callbackId: string, listener: Callback<T, C>): boolean {\n    const entry = this.s.callbacks.get(callbackId);\n    if (!entry) return false;\n    (entry.listeners ??= []).push(listener as Callback<never, never>);\n    return true;\n  }\n\n  /** Unsubscribe a listener from a callback id. */\n  unsubscribe<T, C extends CallbackContext = CallbackContext>(callbackId: string, listener: Callback<T, C>): boolean {\n    const entry = this.s.callbacks.get(callbackId);\n    if (!entry || !entry.listeners) return false;\n    const index = entry.listeners.indexOf(listener as Callback<never, never>);\n    if (index === -1) return false;\n    entry.listeners.splice(index, 1);\n    return true;\n  }\n\n  /** Run a callback once, notify its listeners, then remove it. */\n  trigger<T>(callbackId: string, data: T): void {\n    const entry = this.s.callbacks.get(callbackId);\n    if (!entry) return;\n    void invoke(entry.callback, data);\n    if (entry.listeners && entry.listeners.length > 0) {\n      for (const listener of [...entry.listeners]) void invokeListener(listener, data);\n    }\n    this.deleteEntry(callbackId, true);\n  }\n\n  /** Trigger with merged context and progress; removes unless `removeAfterTrigger: false`. */\n  triggerWithContext<T, C extends CallbackContext = CallbackContext>(\n    callbackId: string,\n    data: T,\n    options?: TriggerOptions<C>,\n  ): void {\n    const entry = this.s.callbacks.get(callbackId);\n    if (!entry) return;\n    const mergedContext: CallbackContext = {\n      ...entry.context,\n      ...options?.context,\n      ...(options?.progress && { progress: options.progress }),\n    };\n    void invoke(entry.callback, data, mergedContext);\n    if (entry.listeners && entry.listeners.length > 0) {\n      for (const listener of [...entry.listeners]) void invokeListener(listener, data, mergedContext);\n    }\n    if (options?.removeAfterTrigger !== false) this.deleteEntry(callbackId, true);\n  }\n\n  /** Trigger every callback in a group. */\n  triggerGroup<T, C extends CallbackContext = CallbackContext>(groupId: string, data: T, options?: TriggerOptions<C>): void {\n    const group = this.s.groups.get(groupId);\n    if (!group) return;\n    for (const callbackId of [...group]) this.triggerWithContext(callbackId, data, options);\n    if (options?.removeAfterTrigger !== false) this.s.groups.delete(groupId);\n  }\n\n  /**\n   * Run the one durable command registered for a group. A command is retained on rejection so its\n   * caller can retry, and is removed only after its promise settles successfully.\n   */\n  async triggerGroupCommand<T, C extends CallbackContext = CallbackContext>(\n    groupId: string,\n    data: T,\n    options?: { context?: C; removeAfterSuccess?: boolean },\n  ): Promise<void> {\n    const group = this.s.groups.get(groupId);\n    const callbackIds = group ? [...group] : [];\n    const callbackId = callbackIds[0];\n    if (callbackIds.length !== 1 || callbackId === undefined) {\n      throw new Error(`Expected exactly one command callback for group \"${groupId}\", found ${callbackIds.length}`);\n    }\n    const entry = this.s.callbacks.get(callbackId);\n    if (!entry) throw new Error(`Command callback \"${callbackId}\" is no longer available`);\n\n    const mergedContext: CallbackContext = { ...entry.context, ...options?.context };\n    await invoke(entry.callback, data, mergedContext);\n\n    // Observers never control command settlement: the command already acknowledged.\n    for (const listener of entry.listeners ?? []) {\n      try {\n        await invokeListener(listener, data, mergedContext);\n      } catch (error) {\n        // eslint-disable-next-line no-console\n        console.error(\"[overlays/handles] command observer failed\", error);\n      }\n    }\n\n    if (options?.removeAfterSuccess !== false) {\n      this.deleteEntry(callbackId, true);\n      this.s.groups.delete(groupId);\n    }\n  }\n\n  /** Report progress to a callback (or every callback of a group) without removing it. */\n  updateProgress(\n    id: string,\n    progress: number,\n    options?: { status?: ProgressInfo[\"status\"]; error?: Error; groupId?: boolean },\n  ): void {\n    const progressInfo: ProgressInfo = { progress, status: options?.status || \"running\" };\n    if (options?.error !== undefined) progressInfo.error = options.error;\n    if (options?.groupId) {\n      this.triggerGroup(id, null, { progress: progressInfo, removeAfterTrigger: false });\n    } else {\n      this.triggerWithContext(id, null, { progress: progressInfo, removeAfterTrigger: false });\n    }\n  }\n\n  /** Create a new, empty group and return its id. */\n  createGroup(): string {\n    const groupId = newHandleId();\n    this.s.groups.set(groupId, new Set());\n    return groupId;\n  }\n\n  /** Remove one entry (and its group/owner membership). */\n  remove(callbackId: string): void {\n    this.deleteEntry(callbackId, true);\n  }\n\n  /** Alias of `remove` — the preferred name when unregistering a handle on unmount. */\n  unregister(callbackId: string): void {\n    this.remove(callbackId);\n  }\n\n  /** The stored callback or object handle for an id, without invoking it. */\n  get<T = unknown>(callbackId: string): T | undefined {\n    return this.s.callbacks.get(callbackId)?.callback as T | undefined;\n  }\n\n  /** True when the id is registered. */\n  has(callbackId: string): boolean {\n    return this.s.callbacks.has(callbackId);\n  }\n\n  /**\n   * Register an object handle (a widget handle, an editor API, …). The object occupies the slot;\n   * it is never invoked by `trigger`, only retrieved with `get`.\n   */\n  registerWidgetHandle<H extends object>(handle: H, options: { owner?: string } = {}): string {\n    return this.registerEntry(handle, options.owner === undefined ? {} : { owner: options.owner });\n  }\n\n  /** Remove a group and all its callbacks. */\n  removeGroup(groupId: string): void {\n    removeHandleGroup(groupId);\n  }\n\n  /** Remove everything registered with `owner` (an InstanceKey). Returns how many were removed. */\n  disposeOwner(owner: string): number {\n    const s = this.s;\n    const owned = s.owners.get(owner);\n    if (!owned) return 0;\n    s.owners.delete(owner);\n    const ids = [...owned];\n    for (const callbackId of ids) this.deleteEntry(callbackId, false);\n    if (ids.length > 0) this.notifyRegistry();\n    return ids.length;\n  }\n\n  /** Ids currently owned by `owner`. */\n  ownedBy(owner: string): readonly string[] {\n    return [...(this.s.owners.get(owner) ?? [])];\n  }\n\n  /** The member ids of a group (empty when unknown). */\n  groupMembers(groupId: string): readonly string[] {\n    return [...(this.s.groups.get(groupId) ?? [])];\n  }\n\n  /** Total registered entries (diagnostics, leak tests). */\n  size(): number {\n    return this.s.callbacks.size;\n  }\n\n  /**\n   * The one removal path. Reads the entry BEFORE deleting it so group and owner membership shrink\n   * (the old `removeFromGroups`-after-delete bug), then runs the entry's removal hook.\n   */\n  private deleteEntry(callbackId: string, notify: boolean): void {\n    deleteHandleEntry(callbackId, notify);\n  }\n}\n\n/** The process-wide handles registry (state in the global slot; every instance shares it). */\nexport const callbackManager = new CallbackManager();\n\n/** Remove everything owned by an open instance (`overlayId:instanceId`). */\nexport function disposeOwner(owner: string): number {\n  return callbackManager.disposeOwner(owner);\n}\n"],"mappings":";;;;;;;;;;AAoFA,IAAMA,gBAAe,MAAoB,aAAmB;AAG5D,SAAS,OAAO,MAAkB,MAAe,SAAiD;AAChG,MAAI,OAAO,SAAS,WAAY,QAAO;AACvC,SAAQ,KAA4C,MAAM,OAAO;AACnE;AAEA,SAAS,eAAe,UAAkC,MAAe,SAAiD;AACxH,SAAQ,SAAgD,MAAM,OAAO;AACvE;AAQO,IAAM,kBAAN,MAAsB;AAAA,EAC3B,IAAY,IAAkB;AAC5B,WAAOA,cAAa;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,oBAAoB,UAAkC;AACpD,UAAM,YAAY,KAAK,EAAE;AACzB,cAAU,IAAI,QAAQ;AACtB,WAAO,MAAM;AACX,gBAAU,OAAO,QAAQ;AAAA,IAC3B;AAAA,EACF;AAAA,EAEQ,iBAAuB;AAC7B,0BAAsB;AAAA,EACxB;AAAA;AAAA,EAGA,SAAY,UAA+B;AACzC,WAAO,KAAK,cAAc,UAAwB,CAAC,CAAC;AAAA,EACtD;AAAA;AAAA,EAGA,oBACE,UACA,UAA8B,CAAC,GACvB;AACR,WAAO,KAAK,cAAc,UAAwB,OAAO;AAAA,EAC3D;AAAA;AAAA,EAGA,cAAc,MAAkB,SAA0C;AACxE,WAAO,oBAAoB,MAAM,OAAO;AAAA,EAC1C;AAAA;AAAA,EAGA,UAA0D,YAAoB,UAAmC;AAC/G,UAAM,QAAQ,KAAK,EAAE,UAAU,IAAI,UAAU;AAC7C,QAAI,CAAC,MAAO,QAAO;AACnB,KAAC,MAAM,cAAc,CAAC,GAAG,KAAK,QAAkC;AAChE,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,YAA4D,YAAoB,UAAmC;AACjH,UAAM,QAAQ,KAAK,EAAE,UAAU,IAAI,UAAU;AAC7C,QAAI,CAAC,SAAS,CAAC,MAAM,UAAW,QAAO;AACvC,UAAM,QAAQ,MAAM,UAAU,QAAQ,QAAkC;AACxE,QAAI,UAAU,GAAI,QAAO;AACzB,UAAM,UAAU,OAAO,OAAO,CAAC;AAC/B,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,QAAW,YAAoB,MAAe;AAC5C,UAAM,QAAQ,KAAK,EAAE,UAAU,IAAI,UAAU;AAC7C,QAAI,CAAC,MAAO;AACZ,SAAK,OAAO,MAAM,UAAU,IAAI;AAChC,QAAI,MAAM,aAAa,MAAM,UAAU,SAAS,GAAG;AACjD,iBAAW,YAAY,CAAC,GAAG,MAAM,SAAS,EAAG,MAAK,eAAe,UAAU,IAAI;AAAA,IACjF;AACA,SAAK,YAAY,YAAY,IAAI;AAAA,EACnC;AAAA;AAAA,EAGA,mBACE,YACA,MACA,SACM;AACN,UAAM,QAAQ,KAAK,EAAE,UAAU,IAAI,UAAU;AAC7C,QAAI,CAAC,MAAO;AACZ,UAAM,gBAAiC;AAAA,MACrC,GAAG,MAAM;AAAA,MACT,GAAG,SAAS;AAAA,MACZ,GAAI,SAAS,YAAY,EAAE,UAAU,QAAQ,SAAS;AAAA,IACxD;AACA,SAAK,OAAO,MAAM,UAAU,MAAM,aAAa;AAC/C,QAAI,MAAM,aAAa,MAAM,UAAU,SAAS,GAAG;AACjD,iBAAW,YAAY,CAAC,GAAG,MAAM,SAAS,EAAG,MAAK,eAAe,UAAU,MAAM,aAAa;AAAA,IAChG;AACA,QAAI,SAAS,uBAAuB,MAAO,MAAK,YAAY,YAAY,IAAI;AAAA,EAC9E;AAAA;AAAA,EAGA,aAA6D,SAAiB,MAAS,SAAmC;AACxH,UAAM,QAAQ,KAAK,EAAE,OAAO,IAAI,OAAO;AACvC,QAAI,CAAC,MAAO;AACZ,eAAW,cAAc,CAAC,GAAG,KAAK,EAAG,MAAK,mBAAmB,YAAY,MAAM,OAAO;AACtF,QAAI,SAAS,uBAAuB,MAAO,MAAK,EAAE,OAAO,OAAO,OAAO;AAAA,EACzE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,oBACJ,SACA,MACA,SACe;AACf,UAAM,QAAQ,KAAK,EAAE,OAAO,IAAI,OAAO;AACvC,UAAM,cAAc,QAAQ,CAAC,GAAG,KAAK,IAAI,CAAC;AAC1C,UAAM,aAAa,YAAY,CAAC;AAChC,QAAI,YAAY,WAAW,KAAK,eAAe,QAAW;AACxD,YAAM,IAAI,MAAM,oDAAoD,OAAO,YAAY,YAAY,MAAM,EAAE;AAAA,IAC7G;AACA,UAAM,QAAQ,KAAK,EAAE,UAAU,IAAI,UAAU;AAC7C,QAAI,CAAC,MAAO,OAAM,IAAI,MAAM,qBAAqB,UAAU,0BAA0B;AAErF,UAAM,gBAAiC,EAAE,GAAG,MAAM,SAAS,GAAG,SAAS,QAAQ;AAC/E,UAAM,OAAO,MAAM,UAAU,MAAM,aAAa;AAGhD,eAAW,YAAY,MAAM,aAAa,CAAC,GAAG;AAC5C,UAAI;AACF,cAAM,eAAe,UAAU,MAAM,aAAa;AAAA,MACpD,SAAS,OAAO;AAEd,gBAAQ,MAAM,8CAA8C,KAAK;AAAA,MACnE;AAAA,IACF;AAEA,QAAI,SAAS,uBAAuB,OAAO;AACzC,WAAK,YAAY,YAAY,IAAI;AACjC,WAAK,EAAE,OAAO,OAAO,OAAO;AAAA,IAC9B;AAAA,EACF;AAAA;AAAA,EAGA,eACE,IACA,UACA,SACM;AACN,UAAM,eAA6B,EAAE,UAAU,QAAQ,SAAS,UAAU,UAAU;AACpF,QAAI,SAAS,UAAU,OAAW,cAAa,QAAQ,QAAQ;AAC/D,QAAI,SAAS,SAAS;AACpB,WAAK,aAAa,IAAI,MAAM,EAAE,UAAU,cAAc,oBAAoB,MAAM,CAAC;AAAA,IACnF,OAAO;AACL,WAAK,mBAAmB,IAAI,MAAM,EAAE,UAAU,cAAc,oBAAoB,MAAM,CAAC;AAAA,IACzF;AAAA,EACF;AAAA;AAAA,EAGA,cAAsB;AACpB,UAAM,UAAU,YAAY;AAC5B,SAAK,EAAE,OAAO,IAAI,SAAS,oBAAI,IAAI,CAAC;AACpC,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,OAAO,YAA0B;AAC/B,SAAK,YAAY,YAAY,IAAI;AAAA,EACnC;AAAA;AAAA,EAGA,WAAW,YAA0B;AACnC,SAAK,OAAO,UAAU;AAAA,EACxB;AAAA;AAAA,EAGA,IAAiB,YAAmC;AAClD,WAAO,KAAK,EAAE,UAAU,IAAI,UAAU,GAAG;AAAA,EAC3C;AAAA;AAAA,EAGA,IAAI,YAA6B;AAC/B,WAAO,KAAK,EAAE,UAAU,IAAI,UAAU;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,qBAAuC,QAAW,UAA8B,CAAC,GAAW;AAC1F,WAAO,KAAK,cAAc,QAAQ,QAAQ,UAAU,SAAY,CAAC,IAAI,EAAE,OAAO,QAAQ,MAAM,CAAC;AAAA,EAC/F;AAAA;AAAA,EAGA,YAAY,SAAuB;AACjC,sBAAkB,OAAO;AAAA,EAC3B;AAAA;AAAA,EAGA,aAAa,OAAuB;AAClC,UAAM,IAAI,KAAK;AACf,UAAM,QAAQ,EAAE,OAAO,IAAI,KAAK;AAChC,QAAI,CAAC,MAAO,QAAO;AACnB,MAAE,OAAO,OAAO,KAAK;AACrB,UAAM,MAAM,CAAC,GAAG,KAAK;AACrB,eAAW,cAAc,IAAK,MAAK,YAAY,YAAY,KAAK;AAChE,QAAI,IAAI,SAAS,EAAG,MAAK,eAAe;AACxC,WAAO,IAAI;AAAA,EACb;AAAA;AAAA,EAGA,QAAQ,OAAkC;AACxC,WAAO,CAAC,GAAI,KAAK,EAAE,OAAO,IAAI,KAAK,KAAK,CAAC,CAAE;AAAA,EAC7C;AAAA;AAAA,EAGA,aAAa,SAAoC;AAC/C,WAAO,CAAC,GAAI,KAAK,EAAE,OAAO,IAAI,OAAO,KAAK,CAAC,CAAE;AAAA,EAC/C;AAAA;AAAA,EAGA,OAAe;AACb,WAAO,KAAK,EAAE,UAAU;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMQ,YAAY,YAAoB,QAAuB;AAC7D,sBAAkB,YAAY,MAAM;AAAA,EACtC;AACF;AAGO,IAAM,kBAAkB,IAAI,gBAAgB;AAG5C,SAAS,aAAa,OAAuB;AAClD,SAAO,gBAAgB,aAAa,KAAK;AAC3C;","names":["handlesState"]}

package/dist/dock.cjs

@@ -207,10 +207,6 @@ function useDock(options) {
   const [pending, setPending] = (0, import_react2.useState)(null);
   const [geometry, setGeometry] = (0, import_react2.useState)({ viewport: SSR_VIEWPORT, size: { width: 0, height: 0 } });
   const [nudge, setNudge] = (0, import_react2.useState)(null);
-  const [dragging, setDragging] = (0, import_react2.useState)(false);
-  const pressRef = (0, import_react2.useRef)(null);
-  const frameRef = (0, import_react2.useRef)(null);
-  const adoptingRef = (0, import_react2.useRef)(false);
   const restoredRef = (0, import_react2.useRef)(null);
   const chosen = isControlled ? pending && samePosition(pending.forProp, controlled) ? pending.value : controlled : local;
   const raw = chosen ?? defaultPosition;
@@ -307,11 +303,6 @@ function useDock(options) {
     }
   }
   const renderedOffset = placed && offset ? fromScreen(placed, rawCorner, geometry.size, geometry.viewport) : offset;
-  (0, import_react2.useLayoutEffect)(() => {
-    if (!adoptingRef.current) return;
-    adoptingRef.current = false;
-    element?.style.removeProperty("translate");
-  });
   const summonStore = (0, import_react3.useOptionalSummonStore)();
   const laneZ = (0, import_react2.useSyncExternalStore)(
     summonStore ? summonStore.subscribe : noopSubscribe,
@@ -326,16 +317,8 @@ function useDock(options) {
     };
   }, [summonStore, id]);
   const zIndex = laneZ ?? baseZ;
-  (0, import_react2.useEffect)(
-    () => () => {
-      pressRef.current?.cleanup();
-      pressRef.current = null;
-    },
-    []
-  );
   const commit = (0, import_react2.useCallback)((next) => {
     const current = live.current;
-    adoptingRef.current = true;
     if (current.isControlled) setPending({ value: next, forProp: current.controlled ?? null });
     else {
       setLocal(next);
@@ -343,106 +326,52 @@ function useDock(options) {
     }
     current.onPositionChange?.(next);
   }, []);
-  const onPointerDown = (0, import_react2.useCallback)(
-    (event) => {
-      if (!draggable || event.button !== 0 || !element) return;
-      if (!touch && event.pointerType === "touch") return;
-      const target = event.target;
-      if (ignore && target) {
-        const hit = target.closest(ignore);
-        if (hit && hit !== event.currentTarget && event.currentTarget.contains(hit)) return;
-      }
-      pressRef.current?.cleanup();
+  const pressRef = (0, import_react2.useRef)({ corner, viewport: SSR_VIEWPORT });
+  const keepScreen = (point, size, viewport) => toScreen(clampOffset(fromScreen(point, "top-left", size, viewport), "top-left", size, viewport, live.current.clamp), "top-left", size, viewport);
+  const drag = (0, import_design_system.useDragMove)({
+    element,
+    enabled: draggable,
+    touch,
+    threshold,
+    ignore,
+    onPress: () => {
       if (raiseOnPress && summonStore) summonStore.dispatch((0, import_summon.raiseTransientWindow)(id));
-      if (!target?.closest("button,a,input,select,textarea,label,[role=button]")) event.preventDefault();
-      const rect = element.getBoundingClientRect();
+    },
+    // A placed dock starts from its committed offset (the host may add lifts on top of it);
+    // a resting dock starts from where it is on screen.
+    getRect: () => {
       const viewport = readViewport();
       const size = measure(element);
-      const press = {
-        pointerId: event.pointerId,
-        startX: event.clientX,
-        startY: event.clientY,
-        origin: { left: rect.left, top: rect.top },
-        size,
-        viewport,
-        active: false,
-        latest: { left: rect.left, top: rect.top },
-        release: null,
-        cleanup: () => void 0
-      };
-      const startOffset = live.current.offset ?? fromScreen(press.origin, live.current.rawCorner, size, viewport);
       const startCorner = live.current.rawCorner;
-      const startScreen = toScreen(startOffset, startCorner, size, viewport);
-      const paint = () => {
-        frameRef.current = null;
-        const active = pressRef.current;
-        if (!active || !active.active) return;
-        element.style.translate = `${active.latest.left - startScreen.left}px ${active.latest.top - startScreen.top}px`;
-      };
-      const move = (e) => {
-        if (e.pointerId !== press.pointerId) return;
-        const dx = e.clientX - press.startX;
-        const dy = e.clientY - press.startY;
-        const opts = live.current;
-        if (!press.active) {
-          if (Math.abs(dx) < opts.threshold && Math.abs(dy) < opts.threshold) return;
-          press.active = true;
-          press.release = (0, import_design_system.holdDragCursor)("grabbing");
-          setDragging(true);
-        }
-        const desired = fromScreen({ left: startScreen.left + dx, top: startScreen.top + dy }, startCorner, size, viewport);
-        let next = toScreen(clampOffset(desired, startCorner, size, viewport, opts.clamp), startCorner, size, viewport);
-        if (opts.avoid) {
-          const keep = (p) => toScreen(clampOffset(fromScreen(p, "top-left", size, viewport), "top-left", size, viewport, opts.clamp), "top-left", size, viewport);
-          next = avoidExclusions(next, size, excludedRects(opts.avoid, element), opts.avoid.gap ?? DEFAULT_DOCK_MARGIN, keep);
-        }
-        press.latest = next;
-        if (frameRef.current === null) {
-          if (typeof window.requestAnimationFrame === "function") frameRef.current = window.requestAnimationFrame(paint);
-          else paint();
-        }
-      };
-      const end = (e) => {
-        if (e.pointerId !== press.pointerId) return;
-        press.cleanup();
-        pressRef.current = null;
-        if (!press.active) return;
-        press.release?.();
-        setDragging(false);
-        const opts = live.current;
-        const finalCorner = opts.snapToCorner ? nearestCorner(press.latest, size, viewport) : startCorner;
-        const finalOffset = clampOffset(fromScreen(press.latest, finalCorner, size, viewport), finalCorner, size, viewport, opts.clamp);
-        commit(finalCorner === corner ? { x: finalOffset.x, y: finalOffset.y } : { ...finalOffset, corner: finalCorner });
-        const swallow = (click) => {
-          click.stopPropagation();
-          click.preventDefault();
-        };
-        window.addEventListener("click", swallow, { capture: true, once: true });
-        window.setTimeout(() => window.removeEventListener("click", swallow, { capture: true }), 0);
-      };
-      press.cleanup = () => {
-        window.removeEventListener("pointermove", move);
-        window.removeEventListener("pointerup", end);
-        window.removeEventListener("pointercancel", end);
-        if (frameRef.current !== null) {
-          window.cancelAnimationFrame?.(frameRef.current);
-          frameRef.current = null;
-        }
-        if (!press.active) return;
-        press.release?.();
-        press.release = null;
-      };
-      pressRef.current = press;
-      window.addEventListener("pointermove", move);
-      window.addEventListener("pointerup", end);
-      window.addEventListener("pointercancel", end);
+      const rect = element?.getBoundingClientRect();
+      const startOffset = live.current.offset ?? fromScreen({ left: rect?.left ?? 0, top: rect?.top ?? 0 }, startCorner, size, viewport);
+      pressRef.current = { corner: startCorner, viewport };
+      const start = toScreen(startOffset, startCorner, size, viewport);
+      return { x: start.left, y: start.top, ...size };
     },
-    [commit, corner, draggable, element, id, ignore, raiseOnPress, summonStore, touch]
-  );
-  const reset = (0, import_react2.useCallback)(() => {
-    adoptingRef.current = true;
-    commit(null);
-  }, [commit]);
+    constrain: (rect) => {
+      const { corner: startCorner, viewport } = pressRef.current;
+      const size = { width: rect.width, height: rect.height };
+      const opts = live.current;
+      const desired = fromScreen({ left: rect.x, top: rect.y }, startCorner, size, viewport);
+      let next = toScreen(clampOffset(desired, startCorner, size, viewport, opts.clamp), startCorner, size, viewport);
+      if (opts.avoid)
+        next = avoidExclusions(next, size, excludedRects(opts.avoid, element), opts.avoid.gap ?? DEFAULT_DOCK_MARGIN, (p) => keepScreen(p, size, viewport));
+      return { ...rect, x: next.left, y: next.top };
+    },
+    onCommit: (rect) => {
+      const { corner: startCorner, viewport } = pressRef.current;
+      const size = { width: rect.width, height: rect.height };
+      const latest = { left: rect.x, top: rect.y };
+      const opts = live.current;
+      const finalCorner = opts.snapToCorner ? nearestCorner(latest, size, viewport) : startCorner;
+      const finalOffset = clampOffset(fromScreen(latest, finalCorner, size, viewport), finalCorner, size, viewport, opts.clamp);
+      commit(finalCorner === corner ? { x: finalOffset.x, y: finalOffset.y } : { ...finalOffset, corner: finalCorner });
+    }
+  });
+  const dragging = drag.dragging;
+  const onPointerDown = drag.onPointerDown;
+  const reset = (0, import_react2.useCallback)(() => commit(null), [commit]);
   let style;
   if (renderedOffset) {
     const left = rawCorner.endsWith("left");