@omerdlw/base-framework 1.0.0

package/dist/modules/context-menu/index.js

@@ -0,0 +1,2008 @@
+"use client";
+import { createContext, useState, useRef, useInsertionEffect, useMemo, useEffect, useCallback, useSyncExternalStore, use, useId, isValidElement, useLayoutEffect, cloneElement, Children, useContext } from 'react';
+import { usePathname } from 'next/navigation';
+import 'clsx';
+import 'tailwind-merge';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { AnimatePresence, motion } from 'motion/react';
+import { Icon as Icon$1 } from '@iconify-icon/react';
+import '@radix-ui/react-tooltip';
+import { createPortal } from 'react-dom';
+
+function useRequiredContext(context, hookName, providerName) {
+  const value = use(context);
+  if (value === null) {
+    throw new Error(`${hookName} must be used within ${providerName}`);
+  }
+  return value;
+}
+function useStore(store, selector = (state) => state, isEqual = Object.is) {
+  const cacheRef = useRef({
+    isEqual: null,
+    selected: void 0,
+    selector: null,
+    snapshot: null
+  });
+  const getSelectedSnapshot = useCallback(() => {
+    const snapshot = store.getSnapshot();
+    const cache = cacheRef.current;
+    if (cache.snapshot === snapshot && cache.selector === selector && cache.isEqual === isEqual) {
+      return cache.selected;
+    }
+    const selected = selector(snapshot);
+    if (cache.snapshot !== null && cache.isEqual === isEqual && isEqual(cache.selected, selected)) {
+      cache.snapshot = snapshot;
+      cache.selector = selector;
+      return cache.selected;
+    }
+    cacheRef.current = {
+      isEqual,
+      selected,
+      selector,
+      snapshot
+    };
+    return selected;
+  }, [isEqual, selector, store]);
+  return useSyncExternalStore(
+    store.subscribe,
+    getSelectedSnapshot,
+    getSelectedSnapshot
+  );
+}
+
+// src/utils/string.ts
+function trimToNull(value) {
+  if (value === null || value === void 0) return null;
+  const trimmed = String(value).trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function isImageIconSource(icon) {
+  return typeof icon === "string" && (icon.startsWith("http://") || icon.startsWith("https://") || icon.startsWith("/") || icon.startsWith("data:image/"));
+}
+
+// src/utils/dom.ts
+var isBrowser = typeof window !== "undefined";
+
+// src/utils/number.ts
+function toFiniteNumber(value, fallback = 0) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+// src/utils/object.ts
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function toArray(value) {
+  if (value === null || value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function report(scope, error, level = "error") {
+  if (process.env.NODE_ENV === "production" && typeof window !== "undefined") {
+    return;
+  }
+  console[level](`[${scope}]`, error);
+}
+
+// src/utils/store.ts
+function freezeStoreSnapshot(state) {
+  if (process.env.NODE_ENV === "production" || !state || typeof state !== "object") {
+    return state;
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  const freeze = (value) => {
+    if (seen.has(value) || Object.isFrozen(value)) return;
+    seen.add(value);
+    const prototype = Object.getPrototypeOf(value);
+    if (Array.isArray(value) || prototype === Object.prototype || prototype === null) {
+      for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor && "value" in descriptor && descriptor.value !== null) {
+          if (typeof descriptor.value === "object") freeze(descriptor.value);
+        }
+      }
+    }
+    Object.freeze(value);
+  };
+  freeze(state);
+  return state;
+}
+function createStore(initialState, { freezeSnapshots = true } = {}) {
+  const listeners = /* @__PURE__ */ new Set();
+  const prepare = freezeSnapshots ? freezeStoreSnapshot : (state) => state;
+  let snapshot = prepare(initialState);
+  const publish = (nextStateOrUpdater) => {
+    const nextState = typeof nextStateOrUpdater === "function" ? nextStateOrUpdater(snapshot) : nextStateOrUpdater;
+    if (Object.is(snapshot, nextState)) return false;
+    snapshot = prepare(nextState);
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch (error) {
+        report("CoreStore subscriber", error, "warn");
+      }
+    }
+    return true;
+  };
+  const setState = (updater) => {
+    if (typeof updater === "function") {
+      return publish(updater);
+    }
+    if (snapshot && typeof snapshot === "object" && updater && typeof updater === "object") {
+      return publish({ ...snapshot, ...updater });
+    }
+    return publish(updater);
+  };
+  return Object.freeze({
+    getSnapshot() {
+      return snapshot;
+    },
+    publish,
+    setState,
+    subscribe(listener) {
+      if (typeof listener !== "function") return () => {
+      };
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  });
+}
+
+// src/hooks/use-isomorphic-layout-effect.ts
+var useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;
+var EventEmitter = class {
+  events = /* @__PURE__ */ new Map();
+  debounceTimers = /* @__PURE__ */ new Map();
+  subscribe(event, callback) {
+    if (typeof event !== "string" || !event || typeof callback !== "function") {
+      return () => {
+      };
+    }
+    const listeners = this.events.get(event) || /* @__PURE__ */ new Set();
+    listeners.add(callback);
+    this.events.set(event, listeners);
+    return () => {
+      listeners.delete(callback);
+      if (listeners.size === 0) this.events.delete(event);
+    };
+  }
+  emit(event, payload) {
+    const listeners = this.events.get(event);
+    if (!listeners || listeners.size === 0) return;
+    const snapshot = Array.from(listeners);
+    for (const callback of snapshot) {
+      try {
+        callback(payload);
+      } catch (error) {
+        report(`Event listener (${String(event)})`, error);
+      }
+    }
+  }
+  emitDebounced(event, payload, waitMs = 100) {
+    const existing = this.debounceTimers.get(event);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(() => {
+      this.debounceTimers.delete(event);
+      this.emit(event, payload);
+    }, waitMs);
+    this.debounceTimers.set(event, timer);
+  }
+  cancelDebounced(event) {
+    if (event) {
+      const timer = this.debounceTimers.get(event);
+      if (timer) {
+        clearTimeout(timer);
+        this.debounceTimers.delete(event);
+      }
+    } else {
+      for (const timer of this.debounceTimers.values()) {
+        clearTimeout(timer);
+      }
+      this.debounceTimers.clear();
+    }
+  }
+  unsubscribeAll(event) {
+    this.cancelDebounced(event);
+    if (event) this.events.delete(event);
+    else this.events.clear();
+  }
+  hasListeners(event) {
+    return Boolean(this.events.get(event)?.size);
+  }
+  getListenerCount(event) {
+    return this.events.get(event)?.size || 0;
+  }
+  getAllEvents() {
+    return [...this.events.keys()];
+  }
+};
+var GLOBAL_EVENTS_KEY = /* @__PURE__ */ Symbol.for("__base_framework_global_events__");
+var _global = globalThis;
+_global[GLOBAL_EVENTS_KEY] ?? (_global[GLOBAL_EVENTS_KEY] = new EventEmitter());
+
+// src/kernel/constants.ts
+var DEFAULT_SOURCE = "dynamic";
+var REGISTRY_SOURCES = Object.freeze({
+  STATIC: "static",
+  DYNAMIC: "dynamic",
+  USER: "user"
+});
+var REGISTRY_LIFECYCLES = Object.freeze({
+  IMMEDIATE: "immediate",
+  GRACEFUL: "graceful",
+  PERSISTENT: "persistent",
+  ROUTE: "route"
+});
+var REGISTRY_VALIDATION_MODES = Object.freeze({
+  WARN: "warn",
+  STRICT: "strict"
+});
+var REGISTRY_METADATA_KEYS = Object.freeze([
+  "cleanup",
+  "cleanupDelayMs",
+  "instanceId",
+  "lifecycle",
+  "priority",
+  "source",
+  "scope",
+  "validation"
+]);
+Object.freeze({
+  [REGISTRY_SOURCES.STATIC]: 100,
+  [REGISTRY_SOURCES.DYNAMIC]: 200,
+  [REGISTRY_SOURCES.USER]: 300
+});
+Object.freeze({
+  [REGISTRY_SOURCES.STATIC]: 10,
+  [REGISTRY_SOURCES.DYNAMIC]: 20,
+  [REGISTRY_SOURCES.USER]: 30
+});
+var REGISTRY_LIFECYCLE_VALUES = new Set(
+  Object.values(REGISTRY_LIFECYCLES)
+);
+var REGISTRY_METADATA_KEY_SET = new Set(
+  REGISTRY_METADATA_KEYS
+);
+var REGISTRY_SCOPE_KINDS = Object.freeze({
+  APP: "app",
+  SESSION: "session",
+  ROUTE: "route",
+  INSTANCE: "instance",
+  WORKSPACE: "workspace"
+});
+REGISTRY_SCOPE_KINDS.APP;
+
+// src/kernel/utils.ts
+function parseFiniteNumber(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function getValidString(value, fallback = null) {
+  return trimToNull(value) ?? fallback;
+}
+
+// src/kernel/schema.ts
+function resolveLifecycle(metadata, fallback) {
+  const lifecycle = metadata?.lifecycle ?? metadata?.cleanup;
+  return lifecycle && REGISTRY_LIFECYCLE_VALUES.has(lifecycle) ? lifecycle : fallback;
+}
+function validateRegistryMetadata(metadata) {
+  if (metadata === void 0 || metadata === null)
+    return { issues: [], valid: true };
+  if (!isObject(metadata))
+    return { issues: ["registry metadata must be an object"], valid: false };
+  const issues = [];
+  Object.keys(metadata).forEach((key) => {
+    if (!REGISTRY_METADATA_KEY_SET.has(key))
+      issues.push(`unknown registry metadata field: ${key}`);
+  });
+  if (metadata.source !== void 0 && !getValidString(metadata.source))
+    issues.push("source must be a non-empty string");
+  if (metadata.instanceId !== void 0 && !getValidString(metadata.instanceId))
+    issues.push("instanceId must be a non-empty string");
+  if (metadata.scope !== void 0 && !getValidString(metadata.scope))
+    issues.push("scope must be a non-empty string");
+  if (metadata.priority !== void 0 && parseFiniteNumber(metadata.priority) === null)
+    issues.push("priority must be a finite number");
+  if (metadata.cleanupDelayMs !== void 0) {
+    const delay = parseFiniteNumber(metadata.cleanupDelayMs);
+    if (delay === null || delay < 0)
+      issues.push("cleanupDelayMs must be a non-negative finite number");
+  }
+  const lifecycle = metadata.lifecycle ?? metadata.cleanup;
+  if (lifecycle !== void 0 && !REGISTRY_LIFECYCLE_VALUES.has(String(lifecycle))) {
+    issues.push(
+      `lifecycle must be one of: ${[...REGISTRY_LIFECYCLE_VALUES].join(", ")}`
+    );
+  }
+  if (metadata.validation !== void 0 && !Object.values(REGISTRY_VALIDATION_MODES).includes(
+    metadata.validation
+  )) {
+    issues.push(
+      `validation must be one of: ${Object.values(REGISTRY_VALIDATION_MODES).join(", ")}`
+    );
+  }
+  return { issues, valid: issues.length === 0 };
+}
+function normalizeRegistryMetadata(metadata, {
+  defaultCleanupDelayMs = null,
+  defaultLifecycle = null,
+  defaultSource = DEFAULT_SOURCE
+} = {}) {
+  const registryMeta = isObject(metadata) ? metadata : {};
+  const normalizedDefaultDelay = parseFiniteNumber(defaultCleanupDelayMs);
+  const fallbackCleanupDelayMs = normalizedDefaultDelay !== null && normalizedDefaultDelay >= 0 ? normalizedDefaultDelay : null;
+  const fallbackLifecycle = defaultLifecycle && REGISTRY_LIFECYCLE_VALUES.has(defaultLifecycle) ? defaultLifecycle : null;
+  const source = getValidString(registryMeta.source) || getValidString(defaultSource, DEFAULT_SOURCE) || DEFAULT_SOURCE;
+  const scope = getValidString(registryMeta.scope);
+  const priority = parseFiniteNumber(registryMeta.priority);
+  const lifecycle = resolveLifecycle(registryMeta, fallbackLifecycle);
+  const validation = isValidationMode(registryMeta.validation) ? registryMeta.validation : null;
+  const cleanupDelayCandidate = parseFiniteNumber(registryMeta.cleanupDelayMs);
+  let cleanupDelayMs = cleanupDelayCandidate !== null && cleanupDelayCandidate >= 0 ? cleanupDelayCandidate : fallbackCleanupDelayMs;
+  if (lifecycle === REGISTRY_LIFECYCLES.IMMEDIATE) {
+    cleanupDelayMs = 0;
+  } else if ((lifecycle === REGISTRY_LIFECYCLES.GRACEFUL || lifecycle === REGISTRY_LIFECYCLES.ROUTE) && cleanupDelayMs === null) {
+    cleanupDelayMs = fallbackCleanupDelayMs;
+  }
+  return {
+    cleanupDelayMs,
+    lifecycle,
+    priority,
+    registerOptions: {
+      ...priority !== null && { priority },
+      ...validation === REGISTRY_VALIDATION_MODES.STRICT && { validation },
+      ...scope && { scope }
+    },
+    source,
+    ...scope && { scope },
+    ...validation && { validation }
+  };
+}
+function isValidationMode(value) {
+  return Object.values(REGISTRY_VALIDATION_MODES).includes(value);
+}
+function pickRegistryMetadata(options) {
+  if (!isObject(options)) return {};
+  return Object.fromEntries(
+    REGISTRY_METADATA_KEYS.filter((key) => options[key] !== void 0).map(
+      (key) => [key, options[key]]
+    )
+  );
+}
+function createNoopHandle(status = "rejected", reason = "unknown") {
+  const handle = Object.assign(() => false, {
+    active: false,
+    dispose: () => false,
+    instanceId: null,
+    key: "",
+    priority: 0,
+    reason,
+    source: "",
+    status,
+    type: "",
+    update: () => handle,
+    updatedAt: 0,
+    validation: "warn"
+  });
+  return handle;
+}
+createNoopHandle();
+function getOrCreateGlobalContext(name, defaultValue) {
+  const sym = /* @__PURE__ */ Symbol.for(`@omerdlw/base-framework/context/${name}`);
+  const store = globalThis;
+  if (!store[sym]) {
+    store[sym] = createContext(defaultValue);
+  }
+  return store[sym];
+}
+var RegistryContext = getOrCreateGlobalContext(
+  "RegistryContext",
+  null
+);
+function useRegistryActions() {
+  return useRequiredContext(
+    RegistryContext,
+    "useRegistryActions",
+    "RegistryProvider"
+  ).actions;
+}
+function useRegistrySubscription() {
+  return useRequiredContext(
+    RegistryContext,
+    "useRegistrySubscription",
+    "RegistryProvider"
+  ).subscription;
+}
+function useRegistryEntries(type) {
+  const { getEntriesSnapshot, subscribe } = useRegistrySubscription();
+  const subscribeToType = useCallback(
+    (listener) => subscribe(type, null, listener),
+    [subscribe, type]
+  );
+  const getEntries = useCallback(
+    () => getEntriesSnapshot(type),
+    [getEntriesSnapshot, type]
+  );
+  return useSyncExternalStore(subscribeToType, getEntries, getEntries);
+}
+var EMPTY_MODULES = Object.freeze([]);
+var ModuleHostContext = getOrCreateGlobalContext("ModuleHostContext", null);
+function selectModuleSlice(coreModule, config) {
+  const slice = coreModule.page?.select ? coreModule.page.select(config) : config[coreModule.id];
+  return slice ?? null;
+}
+function createModulePayload(modules, config, metadata = {}) {
+  const payload = {};
+  let hasSlices = false;
+  for (const coreModule of modules) {
+    if (!coreModule.page?.entries) continue;
+    const slice = selectModuleSlice(coreModule, config);
+    if (slice === null) continue;
+    payload[coreModule.id] = slice;
+    hasSlices = true;
+  }
+  if (!hasSlices) return null;
+  return {
+    ...payload,
+    registry: {
+      ...metadata,
+      ...isObject(config.registry) ? config.registry : {}
+    }
+  };
+}
+function useInstalledModules() {
+  return use(ModuleHostContext)?.modules ?? EMPTY_MODULES;
+}
+
+// src/kernel/handlers.ts
+function isPersistentLifecycle(lifecycle) {
+  return lifecycle === REGISTRY_LIFECYCLES.PERSISTENT;
+}
+function runRegistrationBatch(context, executor) {
+  return typeof context.batch === "function" ? context.batch(executor) : executor(context);
+}
+function createEntryCleanupKey(type, key, source, instanceId, scope) {
+  return JSON.stringify([
+    "entry",
+    type,
+    key,
+    scope ?? null,
+    source,
+    instanceId
+  ]);
+}
+function getCleanupScope(context) {
+  return context?.cleanupScope || /* @__PURE__ */ new Map();
+}
+function clearCleanupTimer(scope, cleanupKey) {
+  const lifecycle = scope.get(cleanupKey);
+  if (!lifecycle) return;
+  lifecycle.cancelled = true;
+  if (lifecycle.timerId !== null) clearTimeout(lifecycle.timerId);
+  scope.delete(cleanupKey);
+}
+function scheduleCleanup(scope, cleanupKey, callback, delayMs) {
+  clearCleanupTimer(scope, cleanupKey);
+  const lifecycle = {
+    cancelled: false,
+    timerId: null
+  };
+  lifecycle.timerId = setTimeout(() => {
+    if (lifecycle.cancelled || scope.get(cleanupKey) !== lifecycle) return;
+    scope.delete(cleanupKey);
+    callback();
+  }, delayMs);
+  scope.set(cleanupKey, lifecycle);
+}
+function collectModuleRegistrations(coreModule, slice, pageMetadata, context) {
+  const definition = coreModule.registry;
+  const toEntries = coreModule.page?.entries;
+  if (!definition || !toEntries || slice == null || slice === false) return [];
+  const type = coreModule.id;
+  const items = Array.isArray(slice) ? slice : [slice];
+  const registrations = [];
+  for (const item of items) {
+    if (item == null || item === false) continue;
+    const itemMetadata = isObject(item) && isObject(item.registry) ? item.registry : {};
+    const metadata = { ...pageMetadata, ...itemMetadata };
+    if (metadata.validation === "strict" && !validateRegistryMetadata(metadata).valid) {
+      continue;
+    }
+    const payload = isObject(item) ? Object.fromEntries(
+      Object.entries(item).filter(([key]) => key !== "registry")
+    ) : item;
+    const { cleanupDelayMs, lifecycle, registerOptions, scope, source } = normalizeRegistryMetadata(metadata, {
+      defaultCleanupDelayMs: definition.cleanupDelayMs ?? null,
+      defaultLifecycle: definition.lifecycle,
+      defaultSource: DEFAULT_SOURCE
+    });
+    for (const { key, value } of toEntries(payload, context) ?? []) {
+      const validation = definition.validate?.(value);
+      if (validation && !validation.valid) {
+        report(`Registry ${type} config is invalid`, validation.issues, "warn");
+        continue;
+      }
+      registrations.push({
+        cleanupDelayMs,
+        cleanupKey: createEntryCleanupKey(
+          type,
+          key,
+          source,
+          context.instanceId,
+          scope
+        ),
+        key,
+        lifecycle,
+        registerOptions,
+        scope,
+        source,
+        type,
+        value
+      });
+    }
+  }
+  return registrations;
+}
+var NO_CLEANUP = () => {
+};
+function applyRegistryConfig(config, context) {
+  const modules = context.modules ?? [];
+  if (!config || modules.length === 0) return NO_CLEANUP;
+  const pageMetadata = isObject(config.registry) ? config.registry : {};
+  const slices = config;
+  const registrations = modules.flatMap((coreModule) => {
+    try {
+      return collectModuleRegistrations(
+        coreModule,
+        slices[coreModule.id],
+        pageMetadata,
+        context
+      );
+    } catch (error) {
+      report(`Registry apply (${coreModule.id})`, error);
+      return [];
+    }
+  });
+  if (registrations.length === 0) return NO_CLEANUP;
+  const cleanupScope = getCleanupScope(context);
+  const owner = (registration) => ({
+    instanceId: context.instanceId,
+    scope: registration.scope,
+    source: registration.source
+  });
+  runRegistrationBatch(context, (queue) => {
+    registrations.forEach(
+      ({ cleanupKey, key, registerOptions, source, type, value }) => {
+        clearCleanupTimer(cleanupScope, cleanupKey);
+        queue.register(type, key, value, source, registerOptions);
+      }
+    );
+  });
+  return () => {
+    const immediate = [];
+    registrations.forEach((registration) => {
+      if (isPersistentLifecycle(registration.lifecycle)) return;
+      const { cleanupDelayMs, cleanupKey, key, type } = registration;
+      if (typeof cleanupDelayMs === "number" && cleanupDelayMs > 0) {
+        scheduleCleanup(
+          cleanupScope,
+          cleanupKey,
+          () => context.unregister(type, key, owner(registration)),
+          cleanupDelayMs
+        );
+      } else {
+        immediate.push(registration);
+      }
+    });
+    if (immediate.length === 0) return;
+    runRegistrationBatch(context, (queue) => {
+      immediate.forEach(
+        (registration) => queue.unregister(
+          registration.type,
+          registration.key,
+          owner(registration)
+        )
+      );
+    });
+  };
+}
+
+// src/kernel/hooks.ts
+function withInstanceId(instanceId, sourceOrOptions, optionsArg) {
+  if (typeof sourceOrOptions === "string") {
+    return {
+      optionsArg: { ...isObject(optionsArg) ? optionsArg : {}, instanceId },
+      sourceOrOptions
+    };
+  }
+  if (isObject(sourceOrOptions)) {
+    return {
+      optionsArg,
+      sourceOrOptions: { ...sourceOrOptions, instanceId }
+    };
+  }
+  return {
+    optionsArg: void 0,
+    sourceOrOptions: {
+      ...isObject(optionsArg) ? optionsArg : {},
+      instanceId
+    }
+  };
+}
+function withInstanceIdForUnregister(instanceId, sourceOrOptions) {
+  if (typeof sourceOrOptions === "string") {
+    return { instanceId, source: sourceOrOptions };
+  }
+  if (isObject(sourceOrOptions)) {
+    return { ...sourceOrOptions, instanceId };
+  }
+  return { instanceId };
+}
+function resolveRegisterArgsWithInstance(instanceId, sourceOrOptions, optionsArg) {
+  const input = withInstanceId(instanceId, sourceOrOptions, optionsArg);
+  return [input.sourceOrOptions, input.optionsArg];
+}
+var MAX_STABILIZATION_DEPTH = 64;
+function createStableFunctionEntry(fn) {
+  const entry = {
+    current: fn,
+    stable(...args) {
+      return entry.current?.apply(this, args);
+    }
+  };
+  return entry;
+}
+function isDirectRegistryComponentPath(path, componentSlices) {
+  const match = /^config\.([^.[]+)\.[^.[]+$/.exec(path);
+  return Boolean(match && componentSlices.has(match[1]));
+}
+function isReactNodeLike(value) {
+  return value === null || value === void 0 || typeof value === "boolean" || typeof value === "string" || typeof value === "number" || isValidElement(value);
+}
+function isStabilizableObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !isValidElement(value);
+}
+function hasSameObjectKeys(previousValue, nextValue) {
+  if (!isStabilizableObject(previousValue) || !isStabilizableObject(nextValue)) {
+    return false;
+  }
+  const previousKeys = Object.keys(previousValue);
+  const nextKeys = Object.keys(nextValue);
+  if (previousKeys.length !== nextKeys.length) return false;
+  return nextKeys.every(
+    (key) => Object.prototype.hasOwnProperty.call(previousValue, key)
+  );
+}
+function stabilizeRegistryValue(value, path, scope, previousValue, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
+  if (depth > MAX_STABILIZATION_DEPTH) return value;
+  if (typeof value === "function") {
+    const isComponent = value.name && /^[A-Z]/.test(value.name);
+    if (isComponent || isDirectRegistryComponentPath(path, scope.componentSlices)) {
+      return value;
+    }
+    scope.usedPaths.add(path);
+    let entry = scope.functionEntries.get(path);
+    if (!entry) {
+      entry = createStableFunctionEntry(value);
+      scope.functionEntries.set(path, entry);
+    } else {
+      entry.current = value;
+    }
+    return entry.stable;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) return value;
+    seen.add(value);
+  }
+  if (isValidElement(value)) {
+    const nextProps = stabilizeRegistryValue(
+      value.props,
+      `${path}.props`,
+      scope,
+      isValidElement(previousValue) ? previousValue.props : void 0,
+      seen,
+      depth + 1
+    );
+    if (isValidElement(previousValue) && previousValue.type === value.type && previousValue.key === value.key && previousValue.props === nextProps) {
+      return previousValue;
+    }
+    return cloneElement(value, nextProps);
+  }
+  if (Array.isArray(value)) {
+    const nextValue = value.every(isReactNodeLike) ? Children.toArray(value) : value;
+    const previousArray = Array.isArray(previousValue) ? previousValue : null;
+    let hasChanged2 = !previousArray || previousArray.length !== nextValue.length;
+    const stabilizedValue2 = nextValue.map((item, index) => {
+      const nextItem = stabilizeRegistryValue(
+        item,
+        `${path}[${index}]`,
+        scope,
+        previousArray?.[index],
+        seen,
+        depth + 1
+      );
+      if (!previousArray || nextItem !== previousArray[index]) {
+        hasChanged2 = true;
+      }
+      return nextItem;
+    });
+    return !hasChanged2 ? previousArray : stabilizedValue2;
+  }
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const source = value;
+  const previousRecord = previousValue;
+  const stabilizedValue = {};
+  const canReusePrevious = hasSameObjectKeys(previousValue, value);
+  let hasChanged = !canReusePrevious;
+  Object.keys(source).forEach((key) => {
+    const nextValue = stabilizeRegistryValue(
+      source[key],
+      `${path}.${key}`,
+      scope,
+      previousRecord?.[key],
+      seen,
+      depth + 1
+    );
+    stabilizedValue[key] = nextValue;
+    if (!canReusePrevious || nextValue !== previousRecord?.[key]) {
+      hasChanged = true;
+    }
+  });
+  return !hasChanged ? previousValue : stabilizedValue;
+}
+function useAppliedRegistryConfig(payload, context, componentSlices) {
+  const functionEntriesRef = useRef(/* @__PURE__ */ new Map());
+  const appliedRef = useRef(null);
+  useIsomorphicLayoutEffect(() => {
+    const previous = appliedRef.current;
+    if (previous && previous.payload === payload && previous.context === context) {
+      return;
+    }
+    const functionEntries = functionEntriesRef.current;
+    const usedPaths = /* @__PURE__ */ new Set();
+    const config = stabilizeRegistryValue(
+      payload,
+      "config",
+      { componentSlices, functionEntries, usedPaths },
+      previous?.config
+    );
+    functionEntries.forEach((_entry, path) => {
+      if (!usedPaths.has(path)) functionEntries.delete(path);
+    });
+    if (previous && previous.config === config && previous.context === context) {
+      previous.payload = payload;
+      return;
+    }
+    previous?.cleanup();
+    appliedRef.current = {
+      cleanup: applyRegistryConfig(config, context),
+      config,
+      context,
+      payload
+    };
+  });
+  useIsomorphicLayoutEffect(
+    () => () => {
+      appliedRef.current?.cleanup();
+      appliedRef.current = null;
+    },
+    []
+  );
+}
+function createRegistryApplyContext(actions, {
+  cleanupScope = /* @__PURE__ */ new Map(),
+  instanceId,
+  modules = [],
+  pathname
+}) {
+  const stamp = (queue) => ({
+    register: (type, key, item, sourceOrOptions, optionsArg) => queue.register(
+      type,
+      key,
+      item,
+      ...resolveRegisterArgsWithInstance(
+        instanceId,
+        sourceOrOptions,
+        optionsArg
+      )
+    ),
+    unregister: (type, key, sourceOrOptions) => queue.unregister(
+      type,
+      key,
+      withInstanceIdForUnregister(instanceId, sourceOrOptions)
+    )
+  });
+  return {
+    ...stamp(actions),
+    batch: (executor) => typeof executor === "function" ? actions.batch((queue) => executor(stamp(queue))) : 0,
+    cleanupScope,
+    instanceId,
+    modules,
+    pathname
+  };
+}
+function useRegistry(config, metadata) {
+  const { batch, register, unregister } = useRegistryActions();
+  const pathname = usePathname();
+  const modules = useInstalledModules();
+  const instanceId = `registry-instance-${useId()}`;
+  const [cleanupScope] = useState(
+    () => /* @__PURE__ */ new Map()
+  );
+  const context = useMemo(
+    () => createRegistryApplyContext(
+      { batch, register, unregister },
+      {
+        cleanupScope,
+        instanceId,
+        modules,
+        pathname
+      }
+    ),
+    [batch, cleanupScope, instanceId, modules, pathname, register, unregister]
+  );
+  const payload = useMemo(
+    () => config ? createModulePayload(modules, config, metadata) : null,
+    [config, metadata, modules]
+  );
+  const componentSlices = useMemo(
+    () => new Set(
+      modules.filter(
+        (coreModule) => coreModule.registry?.valueKind === "component"
+      ).map((coreModule) => coreModule.id)
+    ),
+    [modules]
+  );
+  useAppliedRegistryConfig(payload, context, componentSlices);
+}
+function createPageControllerStore() {
+  const listeners = /* @__PURE__ */ new Set();
+  let stack = [];
+  const notify = () => {
+    listeners.forEach((listener) => {
+      try {
+        listener();
+      } catch (error) {
+        report("Page controller listener", error);
+      }
+    });
+  };
+  return {
+    getSnapshot() {
+      const top = stack[stack.length - 1];
+      return top?.controllerRef?.current || null;
+    },
+    notify,
+    register(id, controllerRef) {
+      stack = stack.filter((item) => item.id !== id);
+      stack.push({ controllerRef, id });
+      notify();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    unregister(id) {
+      stack = stack.filter((item) => item.id !== id);
+      notify();
+    }
+  };
+}
+var fallbackStandaloneStore = createPageControllerStore();
+getOrCreateGlobalContext(
+  "PageControllerContext",
+  null
+);
+getOrCreateGlobalContext(
+  "PageControllerStoreContext",
+  fallbackStandaloneStore
+);
+function defineModule(coreModule) {
+  return Object.freeze({ ...coreModule });
+}
+function useModule(id) {
+  const coreModule = use(ModuleHostContext)?.byId.get(id);
+  return coreModule?.context ? use(coreModule.context) ?? null : null;
+}
+var NO_MODULE_STORE = createStore(void 0);
+function useModuleState(id, selector, fallback, isEqual = Object.is) {
+  const runtime = useModule(id);
+  return useStore(
+    runtime?.store ?? NO_MODULE_STORE,
+    (state) => runtime ? selector(state) : fallback,
+    isEqual
+  );
+}
+
+// src/kernel/adapters.tsx
+function useModuleRegistration(id, value, options) {
+  const coreModule = useInstalledModules().find(
+    (candidate) => candidate.id === id
+  );
+  const config = coreModule && options?.enabled !== false && value != null ? { [id]: value } : null;
+  useRegistry(config, pickRegistryMetadata(options));
+}
+function defineThemeSpec(id) {
+  return Object.freeze({ id });
+}
+var EMPTY = /* @__PURE__ */ new Map();
+var ThemeContext = getOrCreateGlobalContext("ThemeContext", EMPTY);
+function useTheme(spec) {
+  const config = useContext(ThemeContext).get(spec.id);
+  if (!config) {
+    throw new Error(
+      `Theme "${spec.id}" is missing. Add its theme file to src/config/ and list it in src/config/index.ts.`
+    );
+  }
+  return {
+    slots: config.slots,
+    styles: config.styles ?? {}
+  };
+}
+
+// src/modules/context-menu/constants.ts
+var contextMenuTheme = defineThemeSpec("context-menu");
+var CURRENT_PAGE_KEY = "current-page";
+var GLOBAL_MENU_KEY = "*";
+var MENU_SCREEN_MARGIN = 10;
+var CONTEXT_MENU_VISIBILITY_EVENT = "context-menu:visibility";
+var INITIAL_POSITION = Object.freeze({
+  x: 0,
+  y: 0
+});
+function joinClassNames(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+var SCROLL_LOCK_KEYS = /* @__PURE__ */ new Set([
+  "ArrowDown",
+  "ArrowUp",
+  "End",
+  "Home",
+  "PageDown",
+  "PageUp",
+  " ",
+  "Spacebar"
+]);
+function isScrollLockKey(event) {
+  return SCROLL_LOCK_KEYS.has(event.key);
+}
+function extractNodeText(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(extractNodeText).filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
+  }
+  if (isValidElement(value))
+    return extractNodeText(value.props?.children);
+  return "";
+}
+function resolveAsBoolean(value, context, defaultValue = true) {
+  if (typeof value === "function") {
+    try {
+      return Boolean(value(context));
+    } catch {
+      return false;
+    }
+  }
+  if (value === void 0) {
+    return defaultValue;
+  }
+  return Boolean(value);
+}
+function resolveAsValue(value, context, fallback) {
+  if (typeof value === "function") {
+    try {
+      const resolved = value(context);
+      return resolved === void 0 ? fallback : resolved;
+    } catch {
+      return fallback;
+    }
+  }
+  return value === void 0 ? fallback : value;
+}
+function emitContextMenuVisibility(isOpen) {
+  if (!isBrowser) return;
+  window.dispatchEvent(
+    new CustomEvent(CONTEXT_MENU_VISIBILITY_EVENT, {
+      detail: { isOpen: Boolean(isOpen) }
+    })
+  );
+}
+function safeInvoke(handler, ...args) {
+  if (typeof handler !== "function") return void 0;
+  try {
+    const result = handler(...args);
+    if (result && typeof result.then === "function") {
+      result.catch(
+        (err2) => report("Context menu async callback", err2)
+      );
+    }
+    return result;
+  } catch (error) {
+    report("Context menu callback", error);
+    return void 0;
+  }
+}
+function resolveContextMenuPageMeta(dockItem, pathname = "") {
+  if (!isObject(dockItem)) return null;
+  const title = dockItem.contextMenuTitle ?? dockItem.title ?? null;
+  const description = dockItem.contextMenuDescription ?? dockItem.description ?? null;
+  const eyebrow = dockItem.contextMenuEyebrow ?? dockItem.eyebrow ?? null;
+  const icon = dockItem.contextMenuIcon ?? dockItem.icon ?? null;
+  if (!title && !description && !icon && !eyebrow) return null;
+  return {
+    description,
+    descriptionText: extractNodeText(description),
+    eyebrow,
+    icon,
+    path: typeof dockItem.path === "string" && dockItem.path ? dockItem.path : pathname,
+    title,
+    titleText: extractNodeText(title) || (typeof dockItem.name === "string" ? dockItem.name : "") || ""
+  };
+}
+function positionMenu(menuElement, position) {
+  if (!menuElement) return;
+  const { height, width } = menuElement.getBoundingClientRect();
+  const maxX = window.innerWidth - width - MENU_SCREEN_MARGIN;
+  const maxY = window.innerHeight - height - MENU_SCREEN_MARGIN;
+  const x = Math.min(Number(position?.x) || 0, maxX);
+  const y = Math.min(Number(position?.y) || 0, maxY);
+  menuElement.style.left = `${Math.round(Math.max(MENU_SCREEN_MARGIN, x))}px`;
+  menuElement.style.top = `${Math.round(Math.max(MENU_SCREEN_MARGIN, y))}px`;
+}
+function resolveItem(item, index, context) {
+  if (!item) return null;
+  if (item === "separator" || item.type === "separator") {
+    return {
+      key: item !== "separator" && item.key || `separator-${index}`,
+      type: "separator"
+    };
+  }
+  if (resolveAsBoolean(item.hidden, context, false) || !resolveAsBoolean(item.visible, context, true)) {
+    return null;
+  }
+  const label = resolveAsValue(item.label, context, "");
+  if (typeof label !== "string" && typeof label !== "number" || !String(label).trim()) {
+    return null;
+  }
+  const handler = item.onSelect ?? item.onClick ?? null;
+  const shortcut = resolveAsValue(item.shortcut, context, null);
+  return {
+    ...item,
+    className: resolveAsValue(item.className, context, "") || "",
+    closeOnSelect: item.closeOnSelect !== false,
+    danger: resolveAsBoolean(item.danger, context, false),
+    disabled: resolveAsBoolean(item.disabled, context, false),
+    icon: resolveAsValue(item.icon, context, null) || null,
+    itemIconClassName: resolveAsValue(item.itemIconClassName, context, "") || "",
+    key: item.key || `item-${index}`,
+    label: String(label),
+    onClick: handler,
+    onSelect: handler,
+    shortcut: typeof shortcut === "string" ? shortcut : null,
+    type: "action"
+  };
+}
+function resolveMenuItems(config, context) {
+  const rawItems = resolveAsValue(config?.items, context, []);
+  const items = [];
+  toArray(rawItems).forEach((raw, index) => {
+    const item = resolveItem(raw, index, context);
+    if (!item) return;
+    const previous = items[items.length - 1];
+    if (item.type === "separator" && (!previous || previous.type === "separator")) {
+      return;
+    }
+    items.push(item);
+  });
+  if (items[items.length - 1]?.type === "separator") items.pop();
+  return items;
+}
+function resolveMenuHeader(config, context) {
+  if (config?.header === false || config?.showPageHeader === false) return null;
+  const configured = resolveAsValue(config?.header, context, null);
+  const source = isObject(configured) ? configured : isObject(context.page) ? context.page : null;
+  if (!source) return null;
+  const title = resolveAsValue(source.title, context, null);
+  const description = resolveAsValue(source.description, context, null);
+  const icon = resolveAsValue(source.icon, context, null);
+  const eyebrow = resolveAsValue(source.eyebrow, context, null);
+  if (!title && !description && !icon && !eyebrow) return null;
+  return {
+    description,
+    descriptionText: extractNodeText(description),
+    eyebrow,
+    icon,
+    title,
+    titleText: extractNodeText(title)
+  };
+}
+function getNextActiveIndex(items, current, direction) {
+  const count = items.length;
+  const start = current < 0 ? direction === 1 ? 0 : count - 1 : current + direction;
+  for (let step = 0; step < count; step++) {
+    const index = ((start + step * direction) % count + count) % count;
+    if (items[index].type === "action" && !items[index].disabled) return index;
+  }
+  return current;
+}
+
+// src/modules/context-menu/resolver.ts
+function normalizeMenuCandidates(registryMenus) {
+  const candidates = [];
+  for (const [registryKey, rawConfig] of Object.entries(registryMenus || {})) {
+    if (!isObject(rawConfig)) continue;
+    const { menus, ...sharedConfig } = rawConfig;
+    const nestedMenus = toArray(menus);
+    const hasSharedItems = Array.isArray(sharedConfig.items) || typeof sharedConfig.items === "function";
+    if (hasSharedItems || nestedMenus.length === 0) {
+      candidates.push({
+        config: sharedConfig,
+        order: candidates.length,
+        registryKey
+      });
+    }
+    for (const menu of nestedMenus) {
+      candidates.push({
+        config: {
+          ...sharedConfig,
+          ...menu,
+          classNames: { ...sharedConfig.classNames, ...menu.classNames }
+        },
+        order: candidates.length,
+        registryKey
+      });
+    }
+  }
+  return candidates;
+}
+function isPathAllowed(config, registryKey, pathname) {
+  if (!pathname) return true;
+  if (config.path === pathname) return true;
+  const explicitPaths = toArray(config.paths).filter(Boolean);
+  if (explicitPaths.length > 0) return explicitPaths.includes(pathname);
+  if (typeof config.pathMatcher === "function") {
+    try {
+      return Boolean(config.pathMatcher(pathname));
+    } catch {
+      return false;
+    }
+  }
+  return registryKey === pathname || registryKey === CURRENT_PAGE_KEY || registryKey === GLOBAL_MENU_KEY;
+}
+function getElementDepth(from, ancestor) {
+  let depth = 0;
+  for (let node = from; node && node !== ancestor; node = node.parentElement) {
+    depth += 1;
+  }
+  return depth;
+}
+function getTargetScore(config, targetElement) {
+  const selectors = toArray(config.target).filter(
+    (selector) => typeof selector === "string" && selector.trim()
+  );
+  if (selectors.length === 0) return 0;
+  if (!targetElement) return null;
+  let minDepth = Infinity;
+  for (const selector of selectors) {
+    try {
+      const matched = targetElement.closest(selector);
+      if (matched) {
+        minDepth = Math.min(minDepth, getElementDepth(targetElement, matched));
+      }
+    } catch {
+    }
+  }
+  return minDepth === Infinity ? null : Math.max(0, 100 - minDepth);
+}
+function getRouteScore(config, registryKey, pathname) {
+  if (!pathname) return 0;
+  if (config.path === pathname || toArray(config.paths).includes(pathname) || registryKey === pathname) {
+    return 100;
+  }
+  if (registryKey === CURRENT_PAGE_KEY) return 70;
+  if (registryKey === GLOBAL_MENU_KEY) return 40;
+  return 10;
+}
+function buildMenuContext(config, event, pathname, targetElement) {
+  let context = {
+    currentTarget: event.currentTarget ?? null,
+    event,
+    pathname: pathname || "",
+    point: { x: Number(event.clientX) || 0, y: Number(event.clientY) || 0 },
+    target: targetElement
+  };
+  if (config.payload !== void 0) context.payload = config.payload;
+  try {
+    const payload = config.resolvePayload?.(event, context);
+    if (payload !== void 0) context.payload = payload;
+  } catch {
+  }
+  try {
+    const extra = config.resolveContext?.(event, context);
+    if (isObject(extra)) context = { ...context, ...extra };
+  } catch {
+  }
+  return context;
+}
+function isMenuOverlayTarget(element) {
+  return Boolean(
+    element?.closest?.(
+      '[data-context-menu-ignore], [data-context-menu-overlay], [role="menu"]'
+    ) || element?.classList?.contains("context-menu-overlay")
+  );
+}
+function resolveEventTarget(event) {
+  const initialTarget = event.target instanceof Element ? event.target : null;
+  if (initialTarget && !isMenuOverlayTarget(initialTarget)) {
+    return initialTarget;
+  }
+  if (!Number.isFinite(event.clientX) || !Number.isFinite(event.clientY)) {
+    return initialTarget;
+  }
+  try {
+    const underneath = document.elementsFromPoint(event.clientX, event.clientY).find((element) => !isMenuOverlayTarget(element));
+    return underneath || initialTarget;
+  } catch {
+    return initialTarget;
+  }
+}
+function passesWhen(config, event, info) {
+  if (typeof config.when !== "function") return config.when !== false;
+  try {
+    return Boolean(config.when(event, info));
+  } catch {
+    return false;
+  }
+}
+function resolveContextMenu(registryMenus, pathname, event) {
+  const targetElement = resolveEventTarget(event);
+  let winner = null;
+  for (const { config, order, registryKey } of normalizeMenuCandidates(
+    registryMenus
+  )) {
+    if (!isPathAllowed(config, registryKey, pathname)) continue;
+    const context = buildMenuContext(config, event, pathname, targetElement);
+    if (!resolveAsBoolean(config.enabled, context, true)) continue;
+    if (!passesWhen(config, event, {
+      context,
+      pathname: pathname || "",
+      target: targetElement
+    })) {
+      continue;
+    }
+    const items = resolveMenuItems(config, context);
+    if (!items.length) continue;
+    const targetScore = getTargetScore(config, targetElement);
+    if (targetScore === null) continue;
+    const priority = Number(config.priority);
+    const score = (Number.isFinite(priority) ? priority : 0) * 1e4 + getRouteScore(config, registryKey, pathname) * 100 + targetScore;
+    if (!winner || score > winner.score) {
+      winner = { config, context, items, order, score };
+    }
+  }
+  return winner;
+}
+function prepareMenu(config, context, event) {
+  const onOpenResult = safeInvoke(config.onOpen, event, context);
+  if (onOpenResult === false) return null;
+  const nextContext = isObject(onOpenResult) ? { ...context, ...onOpenResult } : context;
+  const items = resolveMenuItems(config, nextContext);
+  return items.length ? { context: nextContext, items } : null;
+}
+
+// src/modules/context-menu/state.ts
+function createInitialMenuState() {
+  return {
+    position: INITIAL_POSITION,
+    context: null,
+    isOpen: false,
+    config: null,
+    items: []
+  };
+}
+function resolveNextOpenState({
+  config,
+  context,
+  items,
+  position
+}) {
+  if (!config) return null;
+  return {
+    config,
+    context: context ?? null,
+    isOpen: true,
+    items: items ?? [],
+    position: {
+      x: Math.round(toFiniteNumber(position?.x, 0)),
+      y: Math.round(toFiniteNumber(position?.y, 0))
+    }
+  };
+}
+var ContextMenuContext = getOrCreateGlobalContext(
+  "ContextMenuContext",
+  null
+);
+function selectIsOpen(state) {
+  return state.isOpen;
+}
+function ContextMenuProvider({ children }) {
+  const pathname = usePathname();
+  const [store] = useState(
+    () => createStore(createInitialMenuState(), {
+      freezeSnapshots: false
+    })
+  );
+  const isOpen = useStore(store, selectIsOpen);
+  const pathnameRef = useRef(pathname);
+  useInsertionEffect(() => {
+    pathnameRef.current = pathname;
+  }, [pathname]);
+  const actions = useMemo(() => {
+    const openMenu = (input) => {
+      const nextState = resolveNextOpenState(input);
+      if (nextState) store.publish(nextState);
+    };
+    const closeMenu = () => {
+      const current = store.getSnapshot();
+      if (!current.isOpen) return;
+      store.publish(createInitialMenuState());
+      safeInvoke(current.config?.onClose, current.context);
+    };
+    const bind = (payload, configOverride) => ({
+      onContextMenu: (event) => {
+        const config = configOverride || store.getSnapshot().config;
+        if (!config) return;
+        event.preventDefault?.();
+        event.stopPropagation?.();
+        const point = {
+          x: Number(event.clientX ?? 0),
+          y: Number(event.clientY ?? 0)
+        };
+        const context = {
+          currentTarget: event.currentTarget ?? null,
+          event,
+          pathname: pathnameRef.current || "",
+          payload,
+          point,
+          target: event.target ?? null
+        };
+        const prepared = prepareMenu(config, context, event);
+        if (!prepared) return;
+        openMenu({
+          config,
+          context: prepared.context,
+          items: prepared.items,
+          position: point
+        });
+      }
+    });
+    return { bind, closeMenu, openMenu };
+  }, [store]);
+  const contextValue = useMemo(
+    () => ({ actions, store }),
+    [actions, store]
+  );
+  useEffect(() => emitContextMenuVisibility(isOpen), [isOpen]);
+  return /* @__PURE__ */ jsx(ContextMenuContext, { value: contextValue, children });
+}
+function useContextMenuRegistration(config, options) {
+  useModuleRegistration("contextMenu", config, options);
+}
+function useContextMenu(config, options) {
+  useContextMenuRegistration(config || null, options);
+  const { actions, store } = useRequiredContext(
+    ContextMenuContext,
+    "useContextMenu",
+    "ContextMenuProvider"
+  );
+  const state = useStore(store);
+  const ctx = useMemo(
+    () => ({ ...state, ...actions }),
+    [actions, state]
+  );
+  return useMemo(() => {
+    if (!config) return ctx;
+    return {
+      ...ctx,
+      bind: (payload, configOverride) => ctx.bind(payload, { ...config, ...configOverride })
+    };
+  }, [config, ctx]);
+}
+function useContextMenuActions() {
+  return useRequiredContext(
+    ContextMenuContext,
+    "useContextMenuActions",
+    "ContextMenuProvider"
+  ).actions;
+}
+function useContextMenuState() {
+  const { store } = useRequiredContext(
+    ContextMenuContext,
+    "useContextMenuState",
+    "ContextMenuProvider"
+  );
+  return useStore(store);
+}
+function selectDockPageCard(dock) {
+  const card = dock.activeItem;
+  return card && !card.isSurface ? card : null;
+}
+function useContextMenuListener() {
+  const menus = useRegistryEntries(
+    "contextMenu"
+  );
+  const dockCard = useModuleState("dock", selectDockPageCard, null);
+  const { openMenu } = useContextMenuActions();
+  const pathname = usePathname();
+  useEffect(() => {
+    const handleContextMenu = (event) => {
+      const match = resolveContextMenu(menus, pathname || void 0, event);
+      if (!match) return;
+      event.preventDefault();
+      event.stopPropagation();
+      const page = resolveContextMenuPageMeta(dockCard, pathname || "");
+      const prepared = prepareMenu(
+        match.config,
+        page ? { ...match.context, page } : match.context,
+        event
+      );
+      if (!prepared) return;
+      openMenu({
+        config: match.config,
+        context: prepared.context,
+        items: prepared.items,
+        position: { x: event.clientX, y: event.clientY }
+      });
+    };
+    document.addEventListener("contextmenu", handleContextMenu, true);
+    return () => document.removeEventListener("contextmenu", handleContextMenu, true);
+  }, [dockCard, menus, openMenu, pathname]);
+}
+function useMenuDismissal(menuRef, onClose) {
+  useEffect(() => {
+    const preventScroll = (event) => event.preventDefault();
+    const listenerOptions = { capture: true, passive: false };
+    const handleInteraction = (event) => {
+      const isInside = menuRef.current?.contains(event.target);
+      if (event.type === "keydown") {
+        if (event.key === "Escape") onClose();
+        if (!isInside && isScrollLockKey(event)) {
+          event.preventDefault();
+        }
+      } else if (!isInside) {
+        onClose();
+      }
+    };
+    document.addEventListener("mousedown", handleInteraction, true);
+    document.addEventListener("keydown", handleInteraction, true);
+    window.addEventListener("wheel", preventScroll, listenerOptions);
+    window.addEventListener("touchmove", preventScroll, listenerOptions);
+    return () => {
+      document.removeEventListener("mousedown", handleInteraction, true);
+      document.removeEventListener("keydown", handleInteraction, true);
+      window.removeEventListener("wheel", preventScroll, true);
+      window.removeEventListener("touchmove", preventScroll, true);
+    };
+  }, [menuRef, onClose]);
+}
+var emptySubscribe = () => () => {
+};
+function useContextMenuContentModel({
+  config,
+  items,
+  menuContext,
+  onClose,
+  position
+}) {
+  const menuRef = useRef(null);
+  const itemRefs = useRef([]);
+  const theme = useTheme(contextMenuTheme);
+  const classes = useMemo(() => {
+    const overrides = config.classNames ?? {};
+    const merged = { ...theme.slots };
+    for (const slot of Object.keys(merged)) {
+      merged[slot] = joinClassNames(theme.slots[slot], overrides[slot]);
+    }
+    return merged;
+  }, [config.classNames, theme.slots]);
+  const header = useMemo(
+    () => resolveMenuHeader(config, menuContext),
+    [config, menuContext]
+  );
+  const [activeIndex, setActiveIndex] = useState(-1);
+  const [prevItems, setPrevItems] = useState(items);
+  if (items !== prevItems) {
+    setPrevItems(items);
+    setActiveIndex(-1);
+  }
+  useLayoutEffect(() => {
+    itemRefs.current = [];
+    positionMenu(menuRef.current, position);
+  }, [header, items, position]);
+  useEffect(() => {
+    const target = activeIndex < 0 ? menuRef.current : itemRefs.current[activeIndex];
+    target?.focus({ preventScroll: true });
+  }, [activeIndex]);
+  useMenuDismissal(menuRef, onClose);
+  const handleItemSelect = useCallback(
+    (item, event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      if (item.disabled) return;
+      safeInvoke(item.onSelect || item.onClick, event, menuContext);
+      if (item.closeOnSelect !== false) onClose();
+    },
+    [menuContext, onClose]
+  );
+  const handleMenuKeyDown = (event) => {
+    if (event.key === "Escape") {
+      event.preventDefault();
+      onClose();
+    } else if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+      event.preventDefault();
+      const direction = event.key === "ArrowDown" ? 1 : -1;
+      setActiveIndex(
+        (current) => getNextActiveIndex(items, current, direction)
+      );
+    } else if ((event.key === "Enter" || event.key === " ") && items[activeIndex]) {
+      event.preventDefault();
+      handleItemSelect(items[activeIndex], event);
+    }
+  };
+  return {
+    menuRef,
+    itemRefs,
+    classes,
+    styles: theme.styles,
+    header,
+    activeIndex,
+    setActiveIndex,
+    handleItemSelect,
+    handleMenuKeyDown
+  };
+}
+function useContextMenuRendererModel() {
+  const { closeMenu, config, context, isOpen, items, position } = useContextMenu();
+  const isMounted = useSyncExternalStore(
+    emptySubscribe,
+    () => true,
+    () => false
+  );
+  return { closeMenu, config, context, isOpen, items, position, isMounted };
+}
+function Icon({
+  className = "center",
+  color,
+  icon,
+  onClick,
+  size = 20,
+  style,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    Icon$1,
+    {
+      className,
+      height: size,
+      icon,
+      onClick,
+      style: { color, ...style },
+      width: size,
+      ...props
+    }
+  );
+}
+Icon.displayName = "Icon";
+
+// src/tokens/motion.ts
+var DURATION_TOKENS = Object.freeze({
+  INSTANT: 0.08,
+  MICRO: 0.18,
+  FAST: 0.28,
+  BASE: 0.36,
+  MODERATE: 0.44,
+  SLOW: 0.58,
+  CINEMATIC: 0.86
+});
+var EASING_CURVES = Object.freeze({
+  OUT_EXPO: [0.16, 1, 0.3, 1],
+  OUT_QUART: [0.25, 1, 0.5, 1],
+  OUT_QUINT: [0.22, 1, 0.36, 1],
+  IN_OUT_CUBIC: [0.65, 0, 0.35, 1],
+  IN_CUBIC: [0.5, 0, 1, 1],
+  OUT_BACK: [0.34, 1.56, 0.64, 1]
+});
+var MOTION_EASINGS = Object.freeze({
+  ENTER: EASING_CURVES.OUT_QUART,
+  ENTER_EMPHASIZED: EASING_CURVES.OUT_EXPO,
+  EXIT: EASING_CURVES.IN_CUBIC
+});
+Object.freeze({
+  MICRO: Object.freeze({
+    distance: 4,
+    duration: DURATION_TOKENS.MICRO,
+    ease: MOTION_EASINGS.ENTER_EMPHASIZED,
+    scaleDelta: 8e-3
+  }),
+  FAST: Object.freeze({
+    distance: 9,
+    duration: DURATION_TOKENS.FAST,
+    ease: MOTION_EASINGS.ENTER_EMPHASIZED,
+    scaleDelta: 0.012
+  }),
+  STANDARD: Object.freeze({
+    distance: 18,
+    duration: DURATION_TOKENS.MODERATE,
+    ease: MOTION_EASINGS.ENTER,
+    scaleDelta: 0.018
+  }),
+  SURFACE: Object.freeze({
+    distance: 28,
+    duration: DURATION_TOKENS.SLOW,
+    ease: MOTION_EASINGS.ENTER_EMPHASIZED,
+    scaleDelta: 0.024
+  })
+});
+Object.freeze({
+  duration: DURATION_TOKENS.INSTANT,
+  ease: "linear"
+});
+
+// src/modules/context-menu/motion.ts
+var CONTEXT_MENU_EASINGS = Object.freeze({
+  EMPHASIZED: EASING_CURVES.OUT_EXPO,
+  SOFT: EASING_CURVES.OUT_QUINT,
+  EXIT: EASING_CURVES.IN_CUBIC
+});
+var CONTEXT_MENU_TIERS = Object.freeze({
+  MICRO: {
+    duration: DURATION_TOKENS.FAST,
+    distance: 4,
+    scaleDelta: 8e-3,
+    ease: CONTEXT_MENU_EASINGS.EMPHASIZED
+  }
+});
+function toGpuTransform({
+  x = 0,
+  y = 0,
+  scale = 1
+} = {}) {
+  return `translate3d(${x}px, ${y}px, 0) scale(${scale})`;
+}
+var CONTEXT_MENU_MICRO_SPRING = Object.freeze({
+  type: "spring",
+  stiffness: 520,
+  damping: 30,
+  mass: 0.28
+});
+var CONTEXT_MENU_ITEM_TAP = Object.freeze({
+  transform: toGpuTransform({
+    scale: 0.97
+  })
+});
+var menuContentVariants = Object.freeze({
+  hidden: {
+    opacity: 0
+  },
+  visible: {
+    opacity: 1,
+    transition: {
+      duration: CONTEXT_MENU_TIERS.MICRO.duration,
+      ease: CONTEXT_MENU_EASINGS.SOFT,
+      delay: 0.04
+    }
+  },
+  exit: {
+    opacity: 0,
+    transition: {
+      duration: DURATION_TOKENS.MICRO,
+      ease: CONTEXT_MENU_EASINGS.EXIT
+    }
+  }
+});
+var menuItemVariants = Object.freeze({
+  hidden: {
+    opacity: 0,
+    transform: toGpuTransform({
+      y: CONTEXT_MENU_TIERS.MICRO.distance,
+      scale: 0.992
+    })
+  },
+  visible: (index = 0) => ({
+    opacity: 1,
+    transform: toGpuTransform(),
+    transition: {
+      duration: CONTEXT_MENU_TIERS.MICRO.duration,
+      ease: CONTEXT_MENU_EASINGS.EMPHASIZED,
+      delay: 0.04 + Math.min(Math.max(Number(index) || 0, 0) * 0.042, 0.21)
+    }
+  }),
+  exit: {
+    opacity: 0,
+    transform: toGpuTransform({
+      y: -3,
+      scale: 0.994
+    }),
+    transition: {
+      duration: DURATION_TOKENS.MICRO,
+      ease: CONTEXT_MENU_EASINGS.EXIT
+    }
+  }
+});
+var menuPopVariants = Object.freeze({
+  hidden: {
+    opacity: 0,
+    transform: toGpuTransform({
+      scale: 0.96
+    }),
+    transformOrigin: "top left"
+  },
+  visible: {
+    opacity: 1,
+    transform: toGpuTransform(),
+    transformOrigin: "top left",
+    transition: {
+      duration: CONTEXT_MENU_TIERS.MICRO.duration,
+      ease: CONTEXT_MENU_EASINGS.EMPHASIZED
+    }
+  },
+  exit: {
+    opacity: 0,
+    transform: toGpuTransform({
+      scale: 0.98
+    }),
+    transformOrigin: "top left",
+    transition: {
+      duration: DURATION_TOKENS.MICRO,
+      ease: CONTEXT_MENU_EASINGS.EXIT
+    }
+  }
+});
+function ContextMenuHeaderIcon({
+  classes,
+  icon
+}) {
+  const iconClassName = classes.headerIcon;
+  if (isImageIconSource(icon)) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: iconClassName,
+        style: { backgroundImage: `url(${icon})` }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx("div", { className: iconClassName, children: typeof icon === "string" ? /* @__PURE__ */ jsx(Icon, { icon, size: 20 }) : icon });
+}
+function ContextMenuHeader({
+  classes,
+  header
+}) {
+  if (!header) return null;
+  return /* @__PURE__ */ jsxs("div", { className: classes.header, children: [
+    header.icon && /* @__PURE__ */ jsx(ContextMenuHeaderIcon, { classes, icon: header.icon }),
+    /* @__PURE__ */ jsxs("div", { className: classes.headerText, children: [
+      header.eyebrow && /* @__PURE__ */ jsx("div", { className: classes.headerEyebrow, children: header.eyebrow }),
+      header.title && /* @__PURE__ */ jsx("div", { className: classes.headerTitle, children: header.title }),
+      header.description && /* @__PURE__ */ jsx("div", { className: classes.headerDescription, children: header.description })
+    ] })
+  ] });
+}
+function ContextMenuItem({
+  classes,
+  isActive,
+  item,
+  onHover,
+  onSelect,
+  setButtonRef
+}) {
+  if (item.type === "separator") {
+    return /* @__PURE__ */ jsx("div", { className: classes.separator, role: "separator" });
+  }
+  const itemClassName = joinClassNames(classes.item, item.className);
+  const itemIconClassName = joinClassNames(
+    classes.itemIcon,
+    item.itemIconClassName
+  );
+  return /* @__PURE__ */ jsxs(
+    motion.button,
+    {
+      ref: setButtonRef,
+      className: itemClassName,
+      "data-active": isActive ? "true" : void 0,
+      "aria-disabled": item.disabled,
+      disabled: item.disabled,
+      role: "menuitem",
+      type: "button",
+      whileTap: CONTEXT_MENU_ITEM_TAP,
+      transition: CONTEXT_MENU_MICRO_SPRING,
+      onMouseEnter: onHover,
+      onClick: (event) => onSelect(item, event),
+      children: [
+        item.icon && (typeof item.icon === "string" ? /* @__PURE__ */ jsx(Icon, { icon: item.icon, className: itemIconClassName, size: 18 }) : item.icon),
+        /* @__PURE__ */ jsx("span", { className: classes.itemLabel, children: item.label }),
+        item.shortcut && /* @__PURE__ */ jsx("span", { className: classes.itemShortcut, children: item.shortcut })
+      ]
+    }
+  );
+}
+var EMPTY_MENU_CONTEXT = Object.freeze({
+  pathname: "",
+  point: { x: 0, y: 0 }
+});
+function ContextMenuContent({
+  config,
+  items,
+  menuContext,
+  onClose,
+  position
+}) {
+  const {
+    menuRef,
+    itemRefs,
+    classes,
+    styles,
+    header,
+    activeIndex,
+    setActiveIndex,
+    handleItemSelect,
+    handleMenuKeyDown
+  } = useContextMenuContentModel({
+    config,
+    items,
+    menuContext,
+    onClose,
+    position
+  });
+  return /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        "data-context-menu-overlay": true,
+        className: classes.backdrop,
+        onMouseDown: onClose,
+        style: styles.backdrop
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      motion.div,
+      {
+        ref: menuRef,
+        "data-context-menu-ignore": true,
+        variants: menuPopVariants,
+        initial: "hidden",
+        animate: "visible",
+        exit: "exit",
+        className: classes.menu,
+        role: "menu",
+        tabIndex: -1,
+        style: {
+          ...styles.menu,
+          left: position.x || 0,
+          top: position.y || 0,
+          position: "fixed"
+        },
+        onMouseLeave: () => setActiveIndex(-1),
+        onKeyDown: handleMenuKeyDown,
+        children: [
+          /* @__PURE__ */ jsx(
+            motion.div,
+            {
+              variants: menuContentVariants,
+              initial: "hidden",
+              animate: "visible",
+              children: /* @__PURE__ */ jsx(ContextMenuHeader, { classes, header })
+            }
+          ),
+          items.map((item, index) => /* @__PURE__ */ jsx(
+            motion.div,
+            {
+              variants: menuItemVariants,
+              custom: index,
+              initial: "hidden",
+              animate: "visible",
+              children: /* @__PURE__ */ jsx(
+                ContextMenuItem,
+                {
+                  item,
+                  classes,
+                  isActive: index === activeIndex,
+                  onHover: () => {
+                    if (item.type === "action" && !item.disabled) {
+                      setActiveIndex(index);
+                    }
+                  },
+                  setButtonRef: (node) => {
+                    itemRefs.current[index] = node;
+                  },
+                  onSelect: handleItemSelect
+                }
+              )
+            },
+            item.key || `menu-item-${index}`
+          ))
+        ]
+      }
+    )
+  ] });
+}
+function ContextMenuRenderer() {
+  const { closeMenu, config, context, isOpen, items, position, isMounted } = useContextMenuRendererModel();
+  if (!isMounted) return null;
+  const menuContext = context ?? EMPTY_MENU_CONTEXT;
+  const resolvedItems = items.length ? items : resolveMenuItems(config, menuContext);
+  return createPortal(
+    /* @__PURE__ */ jsx(AnimatePresence, { children: isOpen && config && resolvedItems.length > 0 && /* @__PURE__ */ jsx(
+      ContextMenuContent,
+      {
+        config,
+        items: resolvedItems,
+        menuContext,
+        position,
+        onClose: closeMenu
+      },
+      "context-menu-content"
+    ) }),
+    document.body
+  );
+}
+function ContextMenuGlobal() {
+  useContextMenuListener();
+  return /* @__PURE__ */ jsx(ContextMenuRenderer, {});
+}
+
+// src/modules/context-menu/module.tsx
+function selectPageContextMenu(config) {
+  return config.contextMenu ?? null;
+}
+function useContextMenuPage(_slice, page) {
+  const actions = useContextMenuActions();
+  return useMemo(
+    () => ({
+      ...actions,
+      set: (contextMenu) => page.set({ contextMenu })
+    }),
+    [actions, page]
+  );
+}
+var contextMenuModule = defineModule({
+  id: "contextMenu",
+  context: ContextMenuContext,
+  Provider: ContextMenuProvider,
+  uses: ["dock"],
+  Overlay: ContextMenuGlobal,
+  registry: {
+    cleanupDelayMs: 600,
+    keyPolicy: "route",
+    lifecycle: "immediate",
+    reservedKeys: [CURRENT_PAGE_KEY, GLOBAL_MENU_KEY]
+  },
+  page: {
+    select: selectPageContextMenu,
+    entries: (slice, { pathname }) => [
+      { key: pathname || CURRENT_PAGE_KEY, value: slice }
+    ],
+    use: useContextMenuPage
+  }
+});
+function defineContextMenu(definition = {}) {
+  return Object.freeze({
+    config: definition,
+    id: definition.id ?? "context-menu",
+    use: function useDefinedContextMenu(options = {}) {
+      return useContextMenu({ ...definition, ...options });
+    }
+  });
+}
+
+export { CONTEXT_MENU_VISIBILITY_EVENT, ContextMenuContext, ContextMenuProvider, contextMenuModule, contextMenuTheme, defineContextMenu, useContextMenu, useContextMenuActions, useContextMenuListener, useContextMenuRegistration, useContextMenuState };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map