@omerdlw/base-framework 1.0.6 → 2.0.0

package/dist/kernel/index.js

@@ -1,2038 +1,5 @@
 "use client";
-import { createContext, useState, useMemo, useCallback, useSyncExternalStore, use, useId, useRef, useEffect, createElement, Fragment as Fragment$1, useLayoutEffect, isValidElement, cloneElement, Children } from 'react';
-import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import { usePathname } from 'next/navigation';
-
-// 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"
-]);
-var REGISTRY_SOURCE_PRIORITY = Object.freeze({
-  [REGISTRY_SOURCES.STATIC]: 100,
-  [REGISTRY_SOURCES.DYNAMIC]: 200,
-  [REGISTRY_SOURCES.USER]: 300
-});
-var REGISTRY_SOURCE_RANK = 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"
-});
-var DEFAULT_REGISTRY_SCOPE = REGISTRY_SCOPE_KINDS.APP;
-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];
-}
-
-// 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;
-}
-
-// src/utils/dom.ts
-var isBrowser = typeof window !== "undefined";
-
-// src/utils/object.ts
-function isObject(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function isPlainObject(value) {
-  if (!isObject(value)) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-function shallowEqual(a, b) {
-  if (Object.is(a, b)) return true;
-  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
-    return false;
-  }
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length) return false;
-  for (const key of keysA) {
-    if (!Object.prototype.hasOwnProperty.call(b, key) || !Object.is(
-      a[key],
-      b[key]
-    )) {
-      return false;
-    }
-  }
-  return true;
-}
-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/kernel/utils.ts
-function hasOwnProperty(target, key) {
-  return Object.prototype.hasOwnProperty.call(target, key);
-}
-function parseFiniteNumber(value) {
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : null;
-}
-function getValidString(value, fallback = null) {
-  return trimToNull(value) ?? fallback;
-}
-function resolveInstanceId(value) {
-  return isObject(value) && typeof value.instanceId === "string" ? value.instanceId : null;
-}
-function getSourceRank(source) {
-  return REGISTRY_SOURCE_RANK[source] ?? 0;
-}
-function resolveRegisterInput(sourceOrOptions, optionsArg) {
-  if (typeof sourceOrOptions === "string") {
-    return {
-      source: sourceOrOptions,
-      options: isObject(optionsArg) ? optionsArg : {}
-    };
-  }
-  if (isObject(sourceOrOptions)) {
-    return {
-      source: typeof sourceOrOptions.source === "string" ? sourceOrOptions.source : DEFAULT_SOURCE,
-      options: sourceOrOptions
-    };
-  }
-  return {
-    source: DEFAULT_SOURCE,
-    options: isObject(optionsArg) ? optionsArg : {}
-  };
-}
-function resolveScope(options) {
-  return typeof options?.scope === "string" && options.scope.trim() ? options.scope.trim() : DEFAULT_REGISTRY_SCOPE;
-}
-function resolveUnregisterInput(sourceOrOptions) {
-  if (typeof sourceOrOptions === "string") {
-    return { instanceId: null, scope: null, source: sourceOrOptions };
-  }
-  if (isObject(sourceOrOptions)) {
-    return {
-      instanceId: resolveInstanceId(sourceOrOptions),
-      scope: typeof sourceOrOptions.scope === "string" && sourceOrOptions.scope.trim() ? sourceOrOptions.scope.trim() : null,
-      source: typeof sourceOrOptions.source === "string" ? sourceOrOptions.source : DEFAULT_SOURCE
-    };
-  }
-  return { instanceId: null, scope: null, source: DEFAULT_SOURCE };
-}
-function mergeModuleConfigs(base, patch) {
-  const source = base;
-  const changes = patch;
-  const result = { ...source };
-  Object.keys(changes).forEach((key) => {
-    const baseVal = source[key];
-    const patchVal = changes[key];
-    if (baseVal && typeof baseVal === "object" && !Array.isArray(baseVal) && patchVal && typeof patchVal === "object" && !Array.isArray(patchVal)) {
-      result[key] = { ...baseVal, ...patchVal };
-    } else {
-      result[key] = patchVal;
-    }
-  });
-  return result;
-}
-
-// 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 validateRegistryKey(type, key, definitions) {
-  const definition = definitions.get(type);
-  const issues = [];
-  if (!definition) issues.push(`unknown registry type: ${String(type)}`);
-  if (!getValidString(key))
-    return {
-      issues: [...issues, "key must be a non-empty string"],
-      valid: false
-    };
-  const normalizedKey = String(key).trim();
-  if (definition?.keyPolicy === "singleton") {
-    const expectedKey = definition.singletonKey;
-    if (expectedKey && normalizedKey !== expectedKey)
-      issues.push(`${type} key must be ${expectedKey}`);
-  } else if (definition?.keyPolicy === "path") {
-    if (!normalizedKey.startsWith("/"))
-      issues.push(`${type} key must be an absolute path`);
-  } else if (definition?.keyPolicy === "route") {
-    if (!normalizedKey.startsWith("/") && !definition.reservedKeys?.includes(normalizedKey)) {
-      issues.push(`${type} key must be a route path or a reserved route key`);
-    }
-  }
-  return { issues, valid: issues.length === 0 };
-}
-function validateRegistryValue(type, key, value, definitions) {
-  const definition = definitions.get(type);
-  const issues = [...validateRegistryKey(type, key, definitions).issues];
-  const valueKind = definition?.valueKind ?? "object";
-  if (definition && valueKind === "object" && !isPlainObject(value)) {
-    issues.push(`${type} values must be plain objects`);
-  }
-  if (definition && valueKind === "component" && typeof value !== "function" && !isPlainObject(value)) {
-    issues.push(
-      `${type} values must be component functions or component objects`
-    );
-  }
-  const validation = definition?.validate?.(value);
-  if (validation && !validation.valid && Array.isArray(validation.issues)) {
-    issues.push(...validation.issues);
-  }
-  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]]
-    )
-  );
-}
-
-// src/kernel/operations.ts
-function createInitialRegistriesFor(definitions) {
-  return Object.fromEntries(
-    Array.from(definitions.keys(), (type) => [type, {}])
-  );
-}
-function buildSourceRecord({
-  source,
-  value,
-  instanceId = null,
-  priority,
-  timestamp,
-  sequence,
-  scope = DEFAULT_REGISTRY_SCOPE
-}) {
-  return {
-    updatedAt: timestamp,
-    sequence: Number.isFinite(sequence) ? sequence : timestamp,
-    instanceId: typeof instanceId === "string" ? instanceId : null,
-    priority,
-    value,
-    source,
-    scope
-  };
-}
-function createRecordKey(source, instanceId = null, scope = DEFAULT_REGISTRY_SCOPE) {
-  if (scope === DEFAULT_REGISTRY_SCOPE) {
-    if (typeof instanceId === "string" && instanceId.length > 0) {
-      return `instance:${JSON.stringify([source, instanceId])}`;
-    }
-    return `source:${JSON.stringify(source)}`;
-  }
-  if (typeof instanceId === "string" && instanceId.length > 0) {
-    return `instance:${JSON.stringify([scope, source, instanceId])}`;
-  }
-  return `source:${JSON.stringify([scope, source])}`;
-}
-function getSourceRecords(entry, source, scope = null) {
-  if (!entry) return [];
-  return Object.entries(entry).map(([recordKey, rawRecord]) => ({
-    recordKey,
-    record: toSourceRecord(rawRecord, recordKey)
-  })).filter(
-    ({ record }) => record?.source === source && (scope === null || record.scope === scope)
-  );
-}
-function getSourceRecord(entry, source, instanceId = null, scope = DEFAULT_REGISTRY_SCOPE) {
-  const recordKey = createRecordKey(source, instanceId, scope);
-  return toSourceRecord(entry?.[recordKey], source);
-}
-function resolveRecordPriority(options, source) {
-  if (isObject(options) && hasOwnProperty(options, "priority")) {
-    const parsedPriority = Number(options.priority);
-    if (Number.isFinite(parsedPriority)) return parsedPriority;
-  }
-  return REGISTRY_SOURCE_PRIORITY[source] ?? 0;
-}
-function toSourceRecord(rawValue, source = DEFAULT_SOURCE) {
-  if (rawValue === void 0) return null;
-  const rawRecord = rawValue;
-  const isWrappedRecord = isObject(rawValue) && hasOwnProperty(rawRecord, "value") && hasOwnProperty(rawRecord, "updatedAt") && hasOwnProperty(rawRecord, "priority") && hasOwnProperty(rawRecord, "source");
-  if (isWrappedRecord) {
-    const parsedPriority = Number(rawRecord.priority);
-    return {
-      updatedAt: Number(rawRecord.updatedAt) || 0,
-      sequence: Number(rawRecord.sequence) || Number(rawRecord.updatedAt) || 0,
-      instanceId: typeof rawRecord.instanceId === "string" ? rawRecord.instanceId : null,
-      priority: Number.isFinite(parsedPriority) ? parsedPriority : REGISTRY_SOURCE_PRIORITY[source] ?? 0,
-      source: typeof rawRecord.source === "string" ? rawRecord.source : source,
-      scope: typeof rawRecord.scope === "string" ? rawRecord.scope : DEFAULT_REGISTRY_SCOPE,
-      value: rawRecord.value
-    };
-  }
-  return {
-    updatedAt: 0,
-    sequence: 0,
-    instanceId: null,
-    priority: REGISTRY_SOURCE_PRIORITY[source] ?? 0,
-    source,
-    scope: DEFAULT_REGISTRY_SCOPE,
-    value: rawValue
-  };
-}
-function compareRecords(a, b) {
-  if (a.priority !== b.priority) return a.priority - b.priority;
-  const rankDiff = getSourceRank(a.source) - getSourceRank(b.source);
-  if (rankDiff !== 0) return rankDiff;
-  return (a.sequence ?? a.updatedAt) - (b.sequence ?? b.updatedAt);
-}
-function recordsHaveSameValue(prevRecord, nextRecord) {
-  if (Object.is(prevRecord?.value, nextRecord?.value)) return true;
-  if (isObject(prevRecord?.value) && isObject(nextRecord?.value)) {
-    return shallowEqual(prevRecord.value, nextRecord.value);
-  }
-  return false;
-}
-function hasRecordChanged(prevRecord, nextRecord) {
-  if (!prevRecord) return true;
-  return prevRecord.priority !== nextRecord.priority || prevRecord.source !== nextRecord.source || prevRecord.instanceId !== nextRecord.instanceId || prevRecord.scope !== nextRecord.scope || !recordsHaveSameValue(prevRecord, nextRecord);
-}
-function hasAnySourceRecord(entry) {
-  return Object.values(entry || {}).some(
-    (rawRecord) => rawRecord !== void 0
-  );
-}
-function setSourceRecord(state, type, key, source, record) {
-  const typeRegistry = state[type] || {};
-  const currentEntry = typeRegistry[key] || {};
-  const recordKey = createRecordKey(source, record.instanceId, record.scope);
-  const prevRecord = toSourceRecord(currentEntry[recordKey], source);
-  if (!hasRecordChanged(prevRecord, record)) {
-    return state;
-  }
-  return {
-    ...state,
-    [type]: {
-      ...typeRegistry,
-      [key]: {
-        ...currentEntry,
-        [recordKey]: record
-      }
-    }
-  };
-}
-function removeSourceRecord(state, type, key, source, instanceId = null, scope = null) {
-  const typeRegistry = state[type];
-  const currentEntry = typeRegistry?.[key];
-  if (!typeRegistry || !currentEntry) return state;
-  let activeRecords = [];
-  if (typeof instanceId === "string" && instanceId.length > 0 && scope !== null) {
-    const safeScope = scope || DEFAULT_REGISTRY_SCOPE;
-    const recordKey = createRecordKey(source, instanceId, safeScope);
-    const record = getSourceRecord(currentEntry, source, instanceId, safeScope);
-    if (record) activeRecords.push({ recordKey, record });
-  } else {
-    activeRecords = getSourceRecords(currentEntry, source, scope).filter(({ record }) => !instanceId || record?.instanceId === instanceId).filter(
-      (entry) => Boolean(entry.record)
-    );
-  }
-  if (activeRecords.length === 0) return state;
-  const nextEntry = { ...currentEntry };
-  activeRecords.forEach(({ recordKey }) => {
-    delete nextEntry[recordKey];
-  });
-  if (!hasAnySourceRecord(nextEntry)) {
-    const nextTypeRegistry = { ...typeRegistry };
-    delete nextTypeRegistry[key];
-    return { ...state, [type]: nextTypeRegistry };
-  }
-  return {
-    ...state,
-    [type]: { ...typeRegistry, [key]: nextEntry }
-  };
-}
-function resolveEntryValueFor(definitions, type, entry, scope = null) {
-  if (!entry) return void 0;
-  const activeRecords = Object.entries(entry).map(([source, rawRecord]) => toSourceRecord(rawRecord, source)).filter(
-    (record) => record !== null && (scope === null || record.scope === scope)
-  );
-  if (activeRecords.length === 0) return void 0;
-  const merge = definitions.get(type)?.merge;
-  if (merge) {
-    const sortedRecords = [...activeRecords].sort(compareRecords);
-    const mergeCandidate = sortedRecords.every(
-      (record) => isObject(record.value)
-    );
-    if (mergeCandidate) {
-      const values = sortedRecords.map(
-        (record) => record.value
-      );
-      return merge(values);
-    }
-    return sortedRecords[sortedRecords.length - 1].value;
-  }
-  return activeRecords.reduce(
-    (winner, current) => compareRecords(current, winner) > 0 ? current : winner
-  ).value;
-}
-function createResolverCacheFor(definitions) {
-  const entryCache = /* @__PURE__ */ new WeakMap();
-  return (type, entry, scope = null) => {
-    if (!entry || typeof entry !== "object") {
-      return resolveEntryValueFor(definitions, type, entry, scope);
-    }
-    let typeCache = entryCache.get(entry);
-    if (!typeCache) {
-      typeCache = /* @__PURE__ */ new Map();
-      entryCache.set(entry, typeCache);
-    }
-    const cacheKey = scope || "default";
-    if (typeCache.has(cacheKey)) return typeCache.get(cacheKey);
-    const value = resolveEntryValueFor(definitions, type, entry, scope);
-    typeCache.set(cacheKey, value);
-    return value;
-  };
-}
-function createRegisterOperation(type, key, item, sourceOrOptions, optionsArg, timestamp, sequence = timestamp) {
-  const { source, options } = resolveRegisterInput(sourceOrOptions, optionsArg);
-  const instanceId = resolveInstanceId(options);
-  const scope = resolveScope(options);
-  return {
-    kind: "register",
-    validation: options.validation,
-    source,
-    scope,
-    record: buildSourceRecord({
-      source,
-      value: item,
-      instanceId,
-      priority: resolveRecordPriority(options, source),
-      scope,
-      timestamp,
-      sequence
-    }),
-    instanceId,
-    type,
-    key: typeof key === "string" ? key.trim() : key
-  };
-}
-function createUnregisterOperation(type, key, sourceOrOptions) {
-  const { scope, source, instanceId } = resolveUnregisterInput(sourceOrOptions);
-  return {
-    kind: "unregister",
-    instanceId,
-    scope,
-    source,
-    type,
-    key: typeof key === "string" ? key.trim() : key
-  };
-}
-function isValidRegistryTargetFor(definitions, type, key) {
-  return validateRegistryKey(type, key, definitions).valid;
-}
-function applyOperationFor(definitions, state, operation) {
-  if (!isValidRegistryTargetFor(definitions, operation?.type, operation?.key))
-    return state;
-  if (operation.kind === "register") {
-    return setSourceRecord(
-      state,
-      operation.type,
-      operation.key,
-      operation.source,
-      operation.record
-    );
-  }
-  if (operation.kind === "unregister") {
-    return removeSourceRecord(
-      state,
-      operation.type,
-      operation.key,
-      operation.source,
-      operation.instanceId,
-      operation.scope
-    );
-  }
-  return state;
-}
-function hasOperationEffectFor(definitions, state, operation) {
-  if (!isValidRegistryTargetFor(definitions, operation?.type, operation?.key))
-    return false;
-  if (operation.kind === "register") {
-    const currentRecord = getSourceRecord(
-      state[operation.type]?.[operation.key],
-      operation.source,
-      operation.instanceId,
-      operation.scope
-    );
-    return hasRecordChanged(currentRecord, operation.record);
-  }
-  if (operation.kind === "unregister") {
-    const entry = state[operation.type]?.[operation.key];
-    if (typeof operation.instanceId === "string" && operation.instanceId.length > 0) {
-      return operation.scope === null ? getSourceRecords(entry, operation.source).some(
-        ({ record }) => record?.instanceId === operation.instanceId
-      ) : Boolean(
-        getSourceRecord(
-          entry,
-          operation.source,
-          operation.instanceId,
-          operation.scope
-        )
-      );
-    }
-    return getSourceRecords(entry, operation.source, operation.scope).length > 0;
-  }
-  return false;
-}
-function resolveEffectiveOperationsFor(definitions, state, operations) {
-  const effectiveOperations = [];
-  let nextState = state;
-  operations.forEach((operation) => {
-    if (!hasOperationEffectFor(definitions, nextState, operation)) return;
-    effectiveOperations.push(operation);
-    nextState = applyOperationFor(definitions, nextState, operation);
-  });
-  return { effectiveOperations, nextState };
-}
-function createRegistryOperations(definitions) {
-  return Object.freeze({
-    applyOperation: (state, operation) => applyOperationFor(definitions, state, operation),
-    createInitialRegistries: () => createInitialRegistriesFor(definitions),
-    createResolverCache: () => createResolverCacheFor(definitions),
-    hasOperationEffect: (state, operation) => hasOperationEffectFor(definitions, state, operation),
-    isRegistryType: (type) => definitions.get(type) !== void 0,
-    isValidRegistryTarget: (type, key) => isValidRegistryTargetFor(definitions, type, key),
-    resolveEffectiveOperations: (state, operations) => resolveEffectiveOperationsFor(definitions, state, operations),
-    resolveEntryValue: (type, entry, scope = null) => resolveEntryValueFor(definitions, type, entry, scope)
-  });
-}
-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
-  );
-}
-var useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;
-
-// src/kernel/runtime.ts
-function createRegistryTransaction(store, metadata = {}) {
-  const operations = [];
-  let status = "open";
-  const traceId = metadata.traceId || `tx-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-  const ensureOpen = () => status === "open";
-  const mergeOptions = (options) => {
-    const baseOpts = options && typeof options === "object" ? options : {};
-    const needsSource = metadata.source && !baseOpts.source;
-    const needsScope = metadata.scope && !baseOpts.scope;
-    if (!needsSource && !needsScope) return baseOpts;
-    return {
-      ...baseOpts,
-      ...needsSource ? { source: metadata.source } : {},
-      ...needsScope ? { scope: metadata.scope } : {}
-    };
-  };
-  const register = (type, key, value, sourceOrOptions, optionsArg) => {
-    if (!ensureOpen()) return { index: -1, status, traceId };
-    const options = typeof sourceOrOptions === "string" ? mergeOptions({ ...optionsArg || {}, source: sourceOrOptions }) : mergeOptions(sourceOrOptions);
-    operations.push({ key, item: value, options, type });
-    return { index: operations.length - 1, status: "queued", traceId };
-  };
-  const unregister = (type, key, sourceOrOptions) => {
-    if (!ensureOpen()) return { index: -1, status, traceId };
-    const options = mergeOptions(
-      typeof sourceOrOptions === "string" ? { source: sourceOrOptions } : sourceOrOptions
-    );
-    operations.push({ key, options, type, unregister: true });
-    return { index: operations.length - 1, status: "queued", traceId };
-  };
-  const rollback = (_reason = "manual") => {
-    if (!ensureOpen()) return { index: -1, status, traceId };
-    status = "rolled-back";
-    operations.length = 0;
-    return { index: -1, status, traceId };
-  };
-  const commit = () => {
-    if (!ensureOpen()) return { status, traceId };
-    status = "committed";
-    const result = store.batch((queue) => {
-      operations.forEach((op) => {
-        if (op.unregister) queue.unregister(op.type, op.key, op.options);
-        else queue.register(op.type, op.key, op.item, op.options);
-      });
-    });
-    const applied = typeof result === "number" && Number.isFinite(result) ? result : 0;
-    return { applied, queued: operations.length, status, traceId };
-  };
-  const run = (executor) => {
-    if (typeof executor !== "function") {
-      rollback("invalid-executor");
-      return { status, traceId };
-    }
-    try {
-      executor({ register, unregister });
-      return commit();
-    } catch (error) {
-      rollback(error instanceof Error ? error.message : String(error));
-      throw error;
-    }
-  };
-  return {
-    commit,
-    get operations() {
-      return operations.slice();
-    },
-    register,
-    rollback,
-    run,
-    get status() {
-      return status;
-    },
-    traceId,
-    unregister
-  };
-}
-
-// src/kernel/store.ts
-var NO_DEFINITIONS = /* @__PURE__ */ new Map();
-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;
-}
-var NOOP_HANDLE = createNoopHandle();
-function isNoopHandle(handle) {
-  return handle === NOOP_HANDLE || handle?.status === "rejected" || handle?.status === "ignored";
-}
-function cloneRegistryValue(value, seen = /* @__PURE__ */ new WeakMap()) {
-  if (value === null || typeof value !== "object" || isValidElement(value)) {
-    return value;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  const isPlainObject2 = !Array.isArray(value) && (prototype === Object.prototype || prototype === null);
-  if (!Array.isArray(value) && !isPlainObject2) return value;
-  if (seen.has(value)) return seen.get(value);
-  const source = value;
-  const clone = Array.isArray(value) ? [] : {};
-  seen.set(value, clone);
-  for (const key in source) {
-    if (Object.prototype.hasOwnProperty.call(source, key)) {
-      clone[key] = cloneRegistryValue(source[key], seen);
-    }
-  }
-  return clone;
-}
-function normalizeInitialEntries(entries) {
-  return (Array.isArray(entries) ? entries : []).filter(
-    (entry) => entry?.type && entry?.items && typeof entry.items === "object"
-  );
-}
-function createInitialState(ops, definitions, entries) {
-  const normalizedEntries = normalizeInitialEntries(entries);
-  if (normalizedEntries.length === 0) return ops.createInitialRegistries();
-  const timestamp = Date.now();
-  let sequence = 0;
-  let state = ops.createInitialRegistries();
-  normalizedEntries.forEach((entry) => {
-    const source = entry.source || REGISTRY_SOURCES.STATIC;
-    const options = {
-      ...entry.options || {},
-      instanceId: entry.instanceId || entry.options?.instanceId || "registry-initial"
-    };
-    Object.entries(entry.items).forEach(([key, value]) => {
-      const validation = validateRegistration(
-        definitions,
-        entry.type,
-        key,
-        value,
-        source,
-        options
-      );
-      if (!validation.valid) return;
-      const operation = createRegisterOperation(
-        entry.type,
-        key,
-        cloneRegistryValue(value),
-        source,
-        options,
-        timestamp,
-        ++sequence
-      );
-      if (ops.hasOperationEffect(state, operation)) {
-        state = ops.applyOperation(state, operation);
-      }
-    });
-  });
-  return state;
-}
-function notifyListeners(listeners) {
-  if (!listeners) return;
-  for (const listener of listeners) {
-    try {
-      listener();
-    } catch (error) {
-      report("Registry listener", error);
-    }
-  }
-}
-function getOrCreateKeyListeners(listenersByType, type, key) {
-  let listeners = listenersByType.get(type);
-  if (!listeners) {
-    listeners = /* @__PURE__ */ new Map();
-    listenersByType.set(type, listeners);
-  }
-  let keyListeners = listeners.get(key);
-  if (!keyListeners) {
-    keyListeners = /* @__PURE__ */ new Set();
-    listeners.set(key, keyListeners);
-  }
-  return keyListeners;
-}
-function resolveRegistrationOptions(sourceOrOptions, optionsArg) {
-  if (sourceOrOptions && typeof sourceOrOptions === "object")
-    return sourceOrOptions;
-  return optionsArg && typeof optionsArg === "object" ? optionsArg : {};
-}
-function validateRegistration(definitions, type, key, value, sourceOrOptions, optionsArg) {
-  const options = resolveRegistrationOptions(sourceOrOptions, optionsArg);
-  const metadataValidation = validateRegistryMetadata(options);
-  const isStrict = options.validation === REGISTRY_VALIDATION_MODES.STRICT;
-  if (!metadataValidation.valid && isStrict) {
-    return {
-      issues: metadataValidation.issues,
-      reason: "invalid-metadata",
-      valid: false
-    };
-  }
-  const validation = validateRegistryValue(type, key, value, definitions);
-  if (validation.valid) return { valid: true };
-  if (!isStrict) {
-    report(`Registry ${type} "${key}" is invalid`, validation.issues, "warn");
-  }
-  return {
-    issues: validation.issues,
-    reason: "invalid-value",
-    valid: !isStrict
-  };
-}
-function createRegistrationHandle(store, operation) {
-  let disposed = false;
-  const dispose = (reason = "manual") => {
-    if (disposed) return false;
-    disposed = true;
-    return store.dispose(operation, reason);
-  };
-  const handle = ((reason) => dispose(reason));
-  handle.dispose = dispose;
-  handle.update = (value, options = {}) => {
-    if (disposed || !store.isCurrent(operation)) return NOOP_HANDLE;
-    const nextHandle = store.register(
-      operation.type,
-      operation.key,
-      value,
-      operation.source,
-      {
-        ...typeof options === "object" ? options : {},
-        instanceId: operation.instanceId,
-        priority: operation.record.priority,
-        ...operation.scope ? { scope: operation.scope } : {},
-        ...operation.validation ? { validation: operation.validation } : {}
-      }
-    );
-    if (isNoopHandle(nextHandle)) return handle;
-    disposed = true;
-    return nextHandle;
-  };
-  Object.defineProperties(handle, {
-    active: {
-      enumerable: true,
-      get: () => !disposed && store.isCurrent(operation)
-    },
-    instanceId: { enumerable: true, value: operation.instanceId },
-    key: { enumerable: true, value: operation.key },
-    priority: { enumerable: true, value: operation.record.priority },
-    source: { enumerable: true, value: operation.source },
-    status: {
-      enumerable: true,
-      get: () => disposed ? "disposed" : store.isCurrent(operation) ? "active" : "superseded"
-    },
-    type: { enumerable: true, value: operation.type },
-    updatedAt: { enumerable: true, value: operation.record.updatedAt },
-    validation: { enumerable: true, value: operation.validation || "warn" }
-  });
-  return handle;
-}
-function prepareRegisterOperation(ops, definitions, type, key, item, sourceOrOptions, optionsArg, timestamp, sequence) {
-  if (!ops.isValidRegistryTarget(type, key)) {
-    return { rejected: createNoopHandle("rejected", "invalid-target") };
-  }
-  const validation = validateRegistration(
-    definitions,
-    type,
-    key,
-    item,
-    sourceOrOptions,
-    optionsArg
-  );
-  if (!validation.valid) {
-    return { rejected: createNoopHandle("rejected", validation.reason) };
-  }
-  return {
-    operation: createRegisterOperation(
-      type,
-      key,
-      cloneRegistryValue(item),
-      sourceOrOptions,
-      optionsArg,
-      timestamp,
-      sequence
-    )
-  };
-}
-function createRegistryStore(initialEntries = [], definitions = NO_DEFINITIONS) {
-  const ops = createRegistryOperations(definitions);
-  let registries = createInitialState(ops, definitions, initialEntries);
-  let sequence = normalizeInitialEntries(initialEntries).reduce(
-    (count, entry) => count + Object.keys(entry.items).length,
-    0
-  );
-  const listenersByType = /* @__PURE__ */ new Map();
-  const entrySnapshots = /* @__PURE__ */ new Map();
-  const valueSnapshots = /* @__PURE__ */ new Map();
-  const resolveCachedValue = ops.createResolverCache();
-  const subscribe = (type, key, listener) => {
-    const keyListeners = getOrCreateKeyListeners(
-      listenersByType,
-      type,
-      key ?? null
-    );
-    keyListeners.add(listener);
-    return () => {
-      keyListeners.delete(listener);
-      if (keyListeners.size > 0) return;
-      const listeners = listenersByType.get(type);
-      if (listeners) {
-        listeners.delete(key ?? null);
-        if (listeners.size === 0) listenersByType.delete(type);
-      }
-    };
-  };
-  const commit = (nextState, operations = []) => {
-    if (registries === nextState) return;
-    const previousState = registries;
-    registries = nextState;
-    const changedKeysByType = /* @__PURE__ */ new Map();
-    for (const operation of operations) {
-      if (!ops.isValidRegistryTarget(operation?.type, operation?.key)) continue;
-      let keys = changedKeysByType.get(operation.type);
-      if (!keys) {
-        keys = /* @__PURE__ */ new Set();
-        changedKeysByType.set(operation.type, keys);
-      }
-      keys.add(operation.key);
-    }
-    for (const [type, changedKeys] of changedKeysByType) {
-      const previousRegistry = previousState[type] || {};
-      const nextRegistry = nextState[type] || {};
-      const typeListeners = listenersByType.get(type);
-      let typeChanged = false;
-      if (!typeListeners) continue;
-      for (const key of changedKeys) {
-        if (previousRegistry[key] === nextRegistry[key]) continue;
-        typeChanged = true;
-        notifyListeners(typeListeners.get(key));
-      }
-      if (typeChanged) {
-        notifyListeners(typeListeners.get(null));
-      }
-    }
-  };
-  const isCurrent = (operation) => {
-    const entry = registries[operation.type]?.[operation.key];
-    const recordKey = createRecordKey(
-      operation.source,
-      operation.instanceId,
-      operation.scope
-    );
-    return entry?.[recordKey] === operation.record;
-  };
-  const dispose = (operation, _reason = "manual") => {
-    if (!isCurrent(operation)) return false;
-    const unregisterOperation = createUnregisterOperation(
-      operation.type,
-      operation.key,
-      {
-        source: operation.source,
-        instanceId: operation.instanceId,
-        scope: operation.scope
-      }
-    );
-    if (!ops.hasOperationEffect(registries, unregisterOperation)) return false;
-    commit(ops.applyOperation(registries, unregisterOperation), [
-      unregisterOperation
-    ]);
-    return true;
-  };
-  const register = (type, key, item, sourceOrOptions = DEFAULT_SOURCE, optionsArg = {}) => {
-    const prepared = prepareRegisterOperation(
-      ops,
-      definitions,
-      type,
-      key,
-      item,
-      sourceOrOptions,
-      optionsArg,
-      Date.now(),
-      ++sequence
-    );
-    if ("rejected" in prepared) return prepared.rejected;
-    const { operation } = prepared;
-    if (!ops.hasOperationEffect(registries, operation)) {
-      return createNoopHandle("ignored", "unchanged");
-    }
-    commit(ops.applyOperation(registries, operation), [operation]);
-    return createRegistrationHandle(store, operation);
-  };
-  const unregister = (type, key, sourceOrOptions = DEFAULT_SOURCE) => {
-    if (!ops.isValidRegistryTarget(type, key)) return;
-    const operation = createUnregisterOperation(type, key, sourceOrOptions);
-    if (!ops.hasOperationEffect(registries, operation)) return;
-    commit(ops.applyOperation(registries, operation), [operation]);
-  };
-  const batch = (executor) => {
-    if (typeof executor !== "function") return 0;
-    const timestamp = Date.now();
-    const operations = [];
-    const queue = {
-      register: (type, key, item, sourceOrOptions = DEFAULT_SOURCE, optionsArg = {}) => {
-        const prepared = prepareRegisterOperation(
-          ops,
-          definitions,
-          type,
-          key,
-          item,
-          sourceOrOptions,
-          optionsArg,
-          timestamp,
-          ++sequence
-        );
-        if ("rejected" in prepared) return prepared.rejected;
-        operations.push(prepared.operation);
-        return createRegistrationHandle(store, prepared.operation);
-      },
-      unregister: (type, key, sourceOrOptions = DEFAULT_SOURCE) => {
-        if (!ops.isValidRegistryTarget(type, key)) return;
-        operations.push(createUnregisterOperation(type, key, sourceOrOptions));
-      }
-    };
-    executor(queue);
-    if (operations.length === 0) return 0;
-    const { effectiveOperations, nextState } = ops.resolveEffectiveOperations(
-      registries,
-      operations
-    );
-    if (effectiveOperations.length === 0) return 0;
-    commit(nextState, effectiveOperations);
-    return effectiveOperations.length;
-  };
-  const getSnapshot = (type, key, scope = null) => {
-    const entry = registries[type]?.[key];
-    let snapshots = valueSnapshots.get(type);
-    if (!snapshots) {
-      snapshots = /* @__PURE__ */ new Map();
-      valueSnapshots.set(type, snapshots);
-    }
-    const cacheKey = scope === null ? key : `${scope}\0${key}`;
-    if (entry === void 0) {
-      snapshots.delete(cacheKey);
-      return void 0;
-    }
-    const cached = snapshots.get(cacheKey);
-    if (cached && cached.entry === entry) return cached.value;
-    const value = resolveCachedValue(type, entry, scope);
-    snapshots.set(cacheKey, { entry, value });
-    return value;
-  };
-  const getEntriesSnapshot = (type, scope = null) => {
-    const typeRegistry = registries[type] || {};
-    const cacheKey = `${type}::${scope ?? "null"}`;
-    const cached = entrySnapshots.get(cacheKey);
-    if (cached?.typeRegistry === typeRegistry) return cached.value;
-    const resolved = {};
-    for (const key in typeRegistry) {
-      if (Object.prototype.hasOwnProperty.call(typeRegistry, key)) {
-        const value = resolveCachedValue(type, typeRegistry[key], scope);
-        if (value !== void 0) resolved[key] = value;
-      }
-    }
-    const finalValue = Object.freeze(resolved);
-    entrySnapshots.set(cacheKey, { typeRegistry, value: finalValue });
-    return finalValue;
-  };
-  const store = {
-    batch,
-    dispose,
-    getEntriesSnapshot,
-    getSnapshot,
-    isCurrent,
-    register,
-    subscribe,
-    transaction: (executor, metadata = {}) => createRegistryTransaction(store, metadata).run(executor),
-    unregister
-  };
-  return store;
-}
-var RegistryContext = getOrCreateGlobalContext(
-  "RegistryContext",
-  null
-);
-function RegistryProvider({
-  children,
-  definitions,
-  initialEntries = []
-}) {
-  const [store] = useState(
-    () => createRegistryStore(initialEntries, definitions)
-  );
-  const contextValue = useMemo(
-    () => ({
-      actions: {
-        batch: store.batch,
-        register: store.register,
-        transaction: store.transaction,
-        unregister: store.unregister
-      },
-      subscription: {
-        getEntriesSnapshot: store.getEntriesSnapshot,
-        getSnapshot: store.getSnapshot,
-        subscribe: store.subscribe
-      }
-    }),
-    [store]
-  );
-  return /* @__PURE__ */ jsx(RegistryContext, { value: contextValue, children });
-}
-function useRegistryActions() {
-  return useRequiredContext(
-    RegistryContext,
-    "useRegistryActions",
-    "RegistryProvider"
-  ).actions;
-}
-function useRegistrySubscription() {
-  return useRequiredContext(
-    RegistryContext,
-    "useRegistrySubscription",
-    "RegistryProvider"
-  ).subscription;
-}
-function useRegistryValue(type, key) {
-  const { getSnapshot, subscribe } = useRegistrySubscription();
-  const subscribeToKey = useCallback(
-    (listener) => subscribe(type, key, listener),
-    [key, subscribe, type]
-  );
-  const getValue = useCallback(
-    () => getSnapshot(type, key),
-    [getSnapshot, key, type]
-  );
-  return useSyncExternalStore(subscribeToKey, getValue, getValue);
-}
-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 PassthroughBoundary = ({ children }) => children;
-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 : {}
-    }
-  };
-}
-var MODULE_ID_PATTERN = /^[a-z][a-zA-Z0-9]*$/;
-function sortModules(modules) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const coreModule of modules) {
-    if (!MODULE_ID_PATTERN.test(coreModule.id)) {
-      throw new Error(
-        `[Core] Invalid module id "${coreModule.id}": use a camelCase name such as "contextMenu".`
-      );
-    }
-    if (byId.has(coreModule.id)) {
-      throw new Error(`[Core] Module "${coreModule.id}" is installed twice.`);
-    }
-    byId.set(coreModule.id, coreModule);
-  }
-  const sorted = [];
-  const state = /* @__PURE__ */ new Map();
-  const visit = (coreModule, path) => {
-    const current = state.get(coreModule.id);
-    if (current === "done") return;
-    if (current === "visiting") {
-      throw new Error(
-        `[Core] Module dependency cycle: ${[...path, coreModule.id].join(" -> ")}`
-      );
-    }
-    state.set(coreModule.id, "visiting");
-    for (const id of coreModule.uses ?? []) {
-      const dependency = byId.get(id);
-      if (dependency) visit(dependency, [...path, coreModule.id]);
-    }
-    state.set(coreModule.id, "done");
-    sorted.push(coreModule);
-  };
-  modules.forEach((coreModule) => visit(coreModule, []));
-  return sorted;
-}
-function createModuleRegistryDefinitions(modules) {
-  const definitions = /* @__PURE__ */ new Map();
-  for (const coreModule of modules) {
-    if (coreModule.registry)
-      definitions.set(coreModule.id, coreModule.registry);
-  }
-  return definitions;
-}
-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];
-}
-function useShallowStable(value) {
-  const ref = useRef(value);
-  if (ref.current !== value && !shallowEqual(ref.current, value)) {
-    ref.current = value;
-  }
-  return ref.current;
-}
-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);
-}
-var EMPTY_OBJECT = Object.freeze({});
-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();
-    }
-  };
-}
-function createControllerScope() {
-  const listeners = /* @__PURE__ */ new Set();
-  let current = null;
-  const subscribe = (listener) => {
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-    };
-  };
-  const getSnapshot = () => current;
-  function PageProvider({ children }) {
-    const controller = useSyncExternalStore(
-      subscribe,
-      getSnapshot,
-      getSnapshot
-    );
-    return /* @__PURE__ */ jsx(PageControllerContext, { value: controller, children });
-  }
-  return {
-    Provider: PageProvider,
-    publish(controller) {
-      if (current === controller) return;
-      current = controller;
-      listeners.forEach((listener) => listener());
-    }
-  };
-}
-var fallbackStandaloneStore = createPageControllerStore();
-var noopHook = () => {
-};
-var PassthroughProvider = ({ children }) => children;
-var PageControllerContext = getOrCreateGlobalContext(
-  "PageControllerContext",
-  null
-);
-var PageControllerStoreContext = getOrCreateGlobalContext(
-  "PageControllerStoreContext",
-  fallbackStandaloneStore
-);
-function PageControllerProvider({ children }) {
-  const [store] = useState(
-    () => createPageControllerStore()
-  );
-  return /* @__PURE__ */ jsx(PageControllerStoreContext, { value: store, children });
-}
-var emptySubscribe = () => () => {
-};
-var getNullSnapshot = () => null;
-var FALLBACK_PAGE_CONTROLLER = Object.freeze({
-  Provider: PassthroughProvider,
-  config: EMPTY_OBJECT,
-  modules: Object.freeze({}),
-  reset: noopHook,
-  set: noopHook
-});
-function usePageController() {
-  const scopedContext = use(PageControllerContext);
-  const controllerStore = use(PageControllerStoreContext);
-  const storeSubscribe = scopedContext ? emptySubscribe : controllerStore.subscribe;
-  const storeSnapshot = scopedContext ? getNullSnapshot : controllerStore.getSnapshot;
-  const storeController = useSyncExternalStore(
-    storeSubscribe,
-    storeSnapshot,
-    getNullSnapshot
-  );
-  return scopedContext ?? storeController ?? FALLBACK_PAGE_CONTROLLER;
-}
-function usePage(pageConfig = EMPTY_OBJECT, options) {
-  const instanceId = useId();
-  const controllerStore = use(PageControllerStoreContext);
-  const modules = useInstalledModules();
-  const [overrides, setOverrides] = useState(EMPTY_OBJECT);
-  const set = useCallback((partial) => {
-    if (!partial || typeof partial !== "object") return;
-    setOverrides((prev) => mergeModuleConfigs(prev, partial));
-  }, []);
-  const reset = useCallback(() => {
-    setOverrides(EMPTY_OBJECT);
-  }, []);
-  const effectiveConfig = useMemo(() => {
-    const base = pageConfig || EMPTY_OBJECT;
-    if (Object.keys(overrides).length === 0) return base;
-    return mergeModuleConfigs(base, overrides);
-  }, [pageConfig, overrides]);
-  const moduleSlices = useMemo(
-    () => modules.map(
-      (coreModule) => selectModuleSlice(coreModule, effectiveConfig)
-    ),
-    [effectiveConfig, modules]
-  );
-  const registryMetadata = useMemo(
-    () => pickRegistryMetadata(options),
-    [options]
-  );
-  useRegistry(effectiveConfig, registryMetadata);
-  const pageApi = useMemo(() => ({ set }), [set]);
-  const moduleControllers = {};
-  for (let index = 0; index < modules.length; index += 1) {
-    const coreModule = modules[index];
-    if (coreModule.page?.use) {
-      moduleControllers[coreModule.id] = coreModule.page.use(
-        moduleSlices[index],
-        pageApi
-      );
-    }
-  }
-  const pageModules = useShallowStable(moduleControllers);
-  const [scope] = useState(createControllerScope);
-  const controller = useMemo(
-    () => ({
-      Provider: scope.Provider,
-      config: effectiveConfig,
-      modules: pageModules,
-      reset,
-      set
-    }),
-    [effectiveConfig, pageModules, reset, scope, set]
-  );
-  const controllerRef = useRef(controller);
-  useIsomorphicLayoutEffect(() => {
-    controllerRef.current = controller;
-    scope.publish(controller);
-    controllerStore.notify();
-  }, [controller, controllerStore, scope]);
-  useEffect(() => {
-    controllerStore.register(instanceId, controllerRef);
-    return () => {
-      controllerStore.unregister(instanceId);
-    };
-  }, [controllerStore, instanceId]);
-  return controller;
-}
-function defineModule(coreModule) {
-  return Object.freeze({ ...coreModule });
-}
-function warnMissingPeers(modules) {
-  const installed = new Set(modules.map((coreModule) => coreModule.id));
-  for (const { id, uses } of modules) {
-    const missing = (uses ?? []).filter((peer) => !installed.has(peer));
-    if (missing.length > 0) {
-      report(
-        `Module "${id}" runs without its optional peers`,
-        missing.join(", "),
-        "warn"
-      );
-    }
-  }
-}
-function createModuleHost(modules, Boundary) {
-  const sorted = sortModules(modules);
-  if (process.env.NODE_ENV !== "production") warnMissingPeers(sorted);
-  return {
-    Boundary,
-    byId: new Map(sorted.map((coreModule) => [coreModule.id, coreModule])),
-    definitions: createModuleRegistryDefinitions(sorted),
-    modules: Object.freeze(sorted)
-  };
-}
-function ModuleHost({
-  boundary = PassthroughBoundary,
-  children,
-  modules = EMPTY_MODULES,
-  registryEntries
-}) {
-  const [host] = useState(() => createModuleHost(modules, boundary));
-  const { Boundary } = host;
-  const content = /* @__PURE__ */ jsxs(Fragment, { children: [
-    host.modules.map(
-      ({ Backdrop, id }) => Backdrop ? /* @__PURE__ */ jsx(Boundary, { name: id, children: /* @__PURE__ */ jsx(Backdrop, {}) }, id) : null
-    ),
-    children,
-    host.modules.map(
-      ({ Overlay, id }) => Overlay ? /* @__PURE__ */ jsx(Boundary, { name: id, children: /* @__PURE__ */ jsx(Overlay, {}) }, id) : null
-    )
-  ] });
-  const tree = host.modules.reduceRight(
-    (inner, { Provider }) => Provider ? /* @__PURE__ */ jsx(Provider, { children: inner }) : inner,
-    content
-  );
-  return /* @__PURE__ */ jsx(
-    RegistryProvider,
-    {
-      definitions: host.definitions,
-      initialEntries: registryEntries,
-      children: /* @__PURE__ */ jsx(ModuleHostContext, { value: host, children: /* @__PURE__ */ jsx(PageControllerProvider, { children: tree }) })
-    }
-  );
-}
-function useModule(id) {
-  const coreModule = use(ModuleHostContext)?.byId.get(id);
-  return coreModule?.context ? use(coreModule.context) ?? null : null;
-}
-function definePeer(id, inert) {
-  const useRuntime = () => useModule(id) ?? inert;
-  return {
-    useRuntime,
-    useActions: () => useRuntime().actions,
-    useState: (selector, isEqual) => useStore(
-      useRuntime().store,
-      selector,
-      isEqual
-    )
-  };
-}
-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
-  );
-}
-function ModuleBoundary({
-  children,
-  name
-}) {
-  const Boundary = use(ModuleHostContext)?.Boundary ?? PassthroughBoundary;
-  return createElement(Boundary, { name }, children);
-}
-function useIsModuleInstalled(id) {
-  return use(ModuleHostContext)?.byId.has(id) ?? false;
-}
-
-// src/kernel/adapters.ts
-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 Compose({ providers, children }) {
-  return providers.reduceRight(
-    (acc, entry) => {
-      if (Array.isArray(entry)) {
-        const [Component2, props] = entry;
-        return createElement(Component2, props, acc);
-      }
-      const Component = entry;
-      return createElement(Component, null, acc);
-    },
-    createElement(Fragment$1, null, children)
-  );
-}
-
-export { Compose, ModuleBoundary, ModuleHost, PageControllerProvider, REGISTRY_SOURCES, RegistryProvider, applyRegistryConfig, createModuleRegistryDefinitions, createRegistryApplyContext, createRegistryOperations, createRegistryStore, defineModule, definePeer, getOrCreateGlobalContext, hasOwnProperty, sortModules, useIsModuleInstalled, useModule, useModuleRegistration, useModuleState, usePage, usePageController, useRegistryEntries, useRegistryValue };
+export { Compose, ModuleBoundary, ModuleHost, PageControllerProvider, REGISTRY_SOURCES, RegistryProvider, applyRegistryConfig, createModuleRegistryDefinitions, createRegistryApplyContext, createRegistryOperations, createRegistryStore, defineModule, definePeer, getOrCreateGlobalContext, hasOwnProperty, sortModules, useIsModuleInstalled, useModule, useModuleRegistration, useModuleState, usePage, usePageController, useRegistryEntries, useRegistryValue } from '../chunk-GF7TUX5I.js';
+import '../chunk-TV3WEF5G.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map