@omerdlw/base-framework 1.0.0

package/dist/kernel/index.js

@@ -0,0 +1,2109 @@
+"use client";
+import 'clsx';
+import 'tailwind-merge';
+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;
+
+// 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;
+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/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;
+}
+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 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.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 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, hasOwnProperty, sortModules, useIsModuleInstalled, useModule, useModuleRegistration, useModuleState, usePage, usePageController, useRegistryEntries, useRegistryValue };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map