@tachui/core 0.7.0-alpha1 → 0.7.1-alpha

package/dist/plugins/simplified-types.js

@@ -1,9 +0,0 @@
-class e extends Error {
-  constructor(r, o) {
-    super(r), this.code = o, this.name = "PluginError";
-  }
-}
-export {
-  e as PluginError
-};
-//# sourceMappingURL=simplified-types.js.map

package/dist/plugins/simplified-types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"simplified-types.js","sources":["../../src/plugins/simplified-types.ts"],"sourcesContent":["/**\n * Simplified Plugin Types - Phase 1 Implementation\n * \n * Streamlined type definitions for the simplified plugin system.\n * Removes complex configuration schemas, security features, and performance monitoring.\n */\n\nimport type { Component } from '../runtime/types'\nimport type { SimplifiedComponentRegistry } from './simplified-component-registry'\n\n/**\n * Simplified plugin interface with essential properties only\n */\nexport interface TachUIPlugin {\n  /** Unique plugin name */\n  name: string\n  \n  /** Plugin version (semver recommended) */\n  version: string\n  \n  /** Plugin description (optional) */\n  description?: string\n  \n  /** Plugin installation function */\n  install(instance: TachUIInstance): Promise<void>\n  \n  /** Plugin uninstallation function (optional) */\n  uninstall?(): Promise<void>\n}\n\n/**\n * Simplified TachUI instance interface for plugins\n */\nexport interface TachUIInstance {\n  /** Register a component with the framework */\n  registerComponent(name: string, component: Component, options?: ComponentRegistrationOptions): void\n  \n  /** Register a service with the framework */\n  registerService(name: string, service: any): void\n  \n  /** Access to component registry */\n  components: SimplifiedComponentRegistry\n  \n  /** Access to services registry */\n  services: Map<string, any>\n}\n\n/**\n * Component registration options (simplified)\n */\nexport interface ComponentRegistrationOptions {\n  /** Component category for organization */\n  category?: string\n  \n  /** Tags for component discovery */\n  tags?: string[]\n  \n  /** Whether to overwrite existing component */\n  overwrite?: boolean\n}\n\n/**\n * Plugin error class for handling plugin-related errors\n */\nexport class PluginError extends Error {\n  constructor(message: string, public code?: string) {\n    super(message)\n    this.name = 'PluginError'\n  }\n}\n\n/**\n * Service registration interface\n */\nexport interface ServiceRegistration {\n  name: string\n  service: any\n  plugin?: string\n}"],"names":["PluginError","message","code"],"mappings":"AAgEO,MAAMA,UAAoB,MAAM;AAAA,EACrC,YAAYC,GAAwBC,GAAe;AACjD,UAAMD,CAAO,GADqB,KAAA,OAAAC,GAElC,KAAK,OAAO;AAAA,EACd;AACF;"}

package/dist/plugins/simplified-utils.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function o(e){return!e||typeof e!="string"?!1:/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/.test(e)}function u(e,a){if(!o(e)||!o(a))throw new Error("Invalid semantic version format");const t=i=>{const[s,l]=i.split("-"),[m,p,c]=s.split(".").map(Number);return{major:m,minor:p,patch:c,prerelease:l}},r=t(e),n=t(a);return r.major!==n.major?r.major<n.major?-1:1:r.minor!==n.minor?r.minor<n.minor?-1:1:r.patch!==n.patch?r.patch<n.patch?-1:1:r.prerelease&&n.prerelease?r.prerelease<n.prerelease?-1:r.prerelease>n.prerelease?1:0:r.prerelease&&!n.prerelease?-1:!r.prerelease&&n.prerelease?1:0}function f(e){return!e||typeof e!="string"?!1:/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(e)}function g(e){return e.replace(/^@[^/]+\//,"")}const v={log(e,a,t){process.env.NODE_ENV==="development"&&(console.group(`🔌 [${e}]`),console.log(a),t&&console.log("Data:",t),console.groupEnd())},warn(e,a){process.env.NODE_ENV==="development"&&console.warn(`⚠️  [${e}] ${a}`)}};exports.PluginDevUtils=v;exports.compareSemver=u;exports.normalizePluginName=g;exports.validatePluginName=f;exports.validateSemver=o;
-//# sourceMappingURL=simplified-utils.cjs.map

package/dist/plugins/simplified-utils.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"simplified-utils.cjs","sources":["../../src/plugins/simplified-utils.ts"],"sourcesContent":["/**\n * Simplified Plugin Utilities - Phase 1 Implementation\n * \n * Essential utility functions only, removing complex debounce/throttle/deepClone\n * functionality that adds unnecessary complexity for simple plugin use cases.\n */\n\n/**\n * Validates a semantic version string\n */\nexport function validateSemver(version: string): boolean {\n  if (!version || typeof version !== 'string') {\n    return false\n  }\n\n  const semverRegex =\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/\n  return semverRegex.test(version)\n}\n\n/**\n * Compares two semantic version strings\n * @param a First version\n * @param b Second version\n * @returns -1 if a < b, 0 if a === b, 1 if a > b\n */\nexport function compareSemver(a: string, b: string): number {\n  if (!validateSemver(a) || !validateSemver(b)) {\n    throw new Error('Invalid semantic version format')\n  }\n\n  const parseVersion = (version: string) => {\n    const [main, prerelease] = version.split('-')\n    const [major, minor, patch] = main.split('.').map(Number)\n    return { major, minor, patch, prerelease }\n  }\n\n  const versionA = parseVersion(a)\n  const versionB = parseVersion(b)\n\n  // Compare major version\n  if (versionA.major !== versionB.major) {\n    return versionA.major < versionB.major ? -1 : 1\n  }\n\n  // Compare minor version\n  if (versionA.minor !== versionB.minor) {\n    return versionA.minor < versionB.minor ? -1 : 1\n  }\n\n  // Compare patch version\n  if (versionA.patch !== versionB.patch) {\n    return versionA.patch < versionB.patch ? -1 : 1\n  }\n\n  // Compare prerelease versions\n  if (versionA.prerelease && versionB.prerelease) {\n    return versionA.prerelease < versionB.prerelease\n      ? -1\n      : versionA.prerelease > versionB.prerelease\n        ? 1\n        : 0\n  }\n\n  // Version with prerelease is less than version without\n  if (versionA.prerelease && !versionB.prerelease) return -1\n  if (!versionA.prerelease && versionB.prerelease) return 1\n\n  return 0\n}\n\n/**\n * Validates plugin name format\n */\nexport function validatePluginName(name: string): boolean {\n  if (!name || typeof name !== 'string') {\n    return false\n  }\n\n  // Allow scoped packages (@scope/name) or simple names\n  const nameRegex = /^(@[a-z0-9-~][a-z0-9-._~]*\\/)?[a-z0-9-~][a-z0-9-._~]*$/\n  return nameRegex.test(name)\n}\n\n/**\n * Normalizes a plugin name (removes @scope/ prefix for ID generation)\n */\nexport function normalizePluginName(name: string): string {\n  return name.replace(/^@[^/]+\\//, '')\n}\n\n/**\n * Simple plugin development utilities for debugging\n */\nexport const PluginDevUtils = {\n  /**\n   * Logs plugin debug information in development mode\n   */\n  log(pluginName: string, message: string, data?: any): void {\n    if (process.env.NODE_ENV === 'development') {\n      console.group(`🔌 [${pluginName}]`)\n      console.log(message)\n      if (data) {\n        console.log('Data:', data)\n      }\n      console.groupEnd()\n    }\n  },\n\n  /**\n   * Creates a development-only warning\n   */\n  warn(pluginName: string, message: string): void {\n    if (process.env.NODE_ENV === 'development') {\n      console.warn(`⚠️  [${pluginName}] ${message}`)\n    }\n  },\n}"],"names":["validateSemver","version","compareSemver","a","b","parseVersion","main","prerelease","major","minor","patch","versionA","versionB","validatePluginName","name","normalizePluginName","PluginDevUtils","pluginName","message","data"],"mappings":"gFAUO,SAASA,EAAeC,EAA0B,CACvD,MAAI,CAACA,GAAW,OAAOA,GAAY,SAC1B,GAIP,sLACiB,KAAKA,CAAO,CACjC,CAQO,SAASC,EAAcC,EAAWC,EAAmB,CAC1D,GAAI,CAACJ,EAAeG,CAAC,GAAK,CAACH,EAAeI,CAAC,EACzC,MAAM,IAAI,MAAM,iCAAiC,EAGnD,MAAMC,EAAgBJ,GAAoB,CACxC,KAAM,CAACK,EAAMC,CAAU,EAAIN,EAAQ,MAAM,GAAG,EACtC,CAACO,EAAOC,EAAOC,CAAK,EAAIJ,EAAK,MAAM,GAAG,EAAE,IAAI,MAAM,EACxD,MAAO,CAAE,MAAAE,EAAO,MAAAC,EAAO,MAAAC,EAAO,WAAAH,CAAA,CAChC,EAEMI,EAAWN,EAAaF,CAAC,EACzBS,EAAWP,EAAaD,CAAC,EAG/B,OAAIO,EAAS,QAAUC,EAAS,MACvBD,EAAS,MAAQC,EAAS,MAAQ,GAAK,EAI5CD,EAAS,QAAUC,EAAS,MACvBD,EAAS,MAAQC,EAAS,MAAQ,GAAK,EAI5CD,EAAS,QAAUC,EAAS,MACvBD,EAAS,MAAQC,EAAS,MAAQ,GAAK,EAI5CD,EAAS,YAAcC,EAAS,WAC3BD,EAAS,WAAaC,EAAS,WAClC,GACAD,EAAS,WAAaC,EAAS,WAC7B,EACA,EAIJD,EAAS,YAAc,CAACC,EAAS,WAAmB,GACpD,CAACD,EAAS,YAAcC,EAAS,WAAmB,EAEjD,CACT,CAKO,SAASC,EAAmBC,EAAuB,CACxD,MAAI,CAACA,GAAQ,OAAOA,GAAS,SACpB,GAIS,yDACD,KAAKA,CAAI,CAC5B,CAKO,SAASC,EAAoBD,EAAsB,CACxD,OAAOA,EAAK,QAAQ,YAAa,EAAE,CACrC,CAKO,MAAME,EAAiB,CAI5B,IAAIC,EAAoBC,EAAiBC,EAAkB,CACrD,QAAQ,IAAI,WAAa,gBAC3B,QAAQ,MAAM,OAAOF,CAAU,GAAG,EAClC,QAAQ,IAAIC,CAAO,EACfC,GACF,QAAQ,IAAI,QAASA,CAAI,EAE3B,QAAQ,SAAA,EAEZ,EAKA,KAAKF,EAAoBC,EAAuB,CAC1C,QAAQ,IAAI,WAAa,eAC3B,QAAQ,KAAK,QAAQD,CAAU,KAAKC,CAAO,EAAE,CAEjD,CACF"}

package/dist/plugins/simplified-utils.js

@@ -1,40 +0,0 @@
-function t(e) {
-  return !e || typeof e != "string" ? !1 : /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/.test(e);
-}
-function u(e, o) {
-  if (!t(e) || !t(o))
-    throw new Error("Invalid semantic version format");
-  const a = (s) => {
-    const [i, l] = s.split("-"), [p, c, m] = i.split(".").map(Number);
-    return { major: p, minor: c, patch: m, prerelease: l };
-  }, r = a(e), n = a(o);
-  return r.major !== n.major ? r.major < n.major ? -1 : 1 : r.minor !== n.minor ? r.minor < n.minor ? -1 : 1 : r.patch !== n.patch ? r.patch < n.patch ? -1 : 1 : r.prerelease && n.prerelease ? r.prerelease < n.prerelease ? -1 : r.prerelease > n.prerelease ? 1 : 0 : r.prerelease && !n.prerelease ? -1 : !r.prerelease && n.prerelease ? 1 : 0;
-}
-function f(e) {
-  return !e || typeof e != "string" ? !1 : /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(e);
-}
-function g(e) {
-  return e.replace(/^@[^/]+\//, "");
-}
-const v = {
-  /**
-   * Logs plugin debug information in development mode
-   */
-  log(e, o, a) {
-    process.env.NODE_ENV === "development" && (console.group(`🔌 [${e}]`), console.log(o), a && console.log("Data:", a), console.groupEnd());
-  },
-  /**
-   * Creates a development-only warning
-   */
-  warn(e, o) {
-    process.env.NODE_ENV === "development" && console.warn(`⚠️  [${e}] ${o}`);
-  }
-};
-export {
-  v as PluginDevUtils,
-  u as compareSemver,
-  g as normalizePluginName,
-  f as validatePluginName,
-  t as validateSemver
-};
-//# sourceMappingURL=simplified-utils.js.map

package/dist/plugins/simplified-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"simplified-utils.js","sources":["../../src/plugins/simplified-utils.ts"],"sourcesContent":["/**\n * Simplified Plugin Utilities - Phase 1 Implementation\n * \n * Essential utility functions only, removing complex debounce/throttle/deepClone\n * functionality that adds unnecessary complexity for simple plugin use cases.\n */\n\n/**\n * Validates a semantic version string\n */\nexport function validateSemver(version: string): boolean {\n  if (!version || typeof version !== 'string') {\n    return false\n  }\n\n  const semverRegex =\n    /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/\n  return semverRegex.test(version)\n}\n\n/**\n * Compares two semantic version strings\n * @param a First version\n * @param b Second version\n * @returns -1 if a < b, 0 if a === b, 1 if a > b\n */\nexport function compareSemver(a: string, b: string): number {\n  if (!validateSemver(a) || !validateSemver(b)) {\n    throw new Error('Invalid semantic version format')\n  }\n\n  const parseVersion = (version: string) => {\n    const [main, prerelease] = version.split('-')\n    const [major, minor, patch] = main.split('.').map(Number)\n    return { major, minor, patch, prerelease }\n  }\n\n  const versionA = parseVersion(a)\n  const versionB = parseVersion(b)\n\n  // Compare major version\n  if (versionA.major !== versionB.major) {\n    return versionA.major < versionB.major ? -1 : 1\n  }\n\n  // Compare minor version\n  if (versionA.minor !== versionB.minor) {\n    return versionA.minor < versionB.minor ? -1 : 1\n  }\n\n  // Compare patch version\n  if (versionA.patch !== versionB.patch) {\n    return versionA.patch < versionB.patch ? -1 : 1\n  }\n\n  // Compare prerelease versions\n  if (versionA.prerelease && versionB.prerelease) {\n    return versionA.prerelease < versionB.prerelease\n      ? -1\n      : versionA.prerelease > versionB.prerelease\n        ? 1\n        : 0\n  }\n\n  // Version with prerelease is less than version without\n  if (versionA.prerelease && !versionB.prerelease) return -1\n  if (!versionA.prerelease && versionB.prerelease) return 1\n\n  return 0\n}\n\n/**\n * Validates plugin name format\n */\nexport function validatePluginName(name: string): boolean {\n  if (!name || typeof name !== 'string') {\n    return false\n  }\n\n  // Allow scoped packages (@scope/name) or simple names\n  const nameRegex = /^(@[a-z0-9-~][a-z0-9-._~]*\\/)?[a-z0-9-~][a-z0-9-._~]*$/\n  return nameRegex.test(name)\n}\n\n/**\n * Normalizes a plugin name (removes @scope/ prefix for ID generation)\n */\nexport function normalizePluginName(name: string): string {\n  return name.replace(/^@[^/]+\\//, '')\n}\n\n/**\n * Simple plugin development utilities for debugging\n */\nexport const PluginDevUtils = {\n  /**\n   * Logs plugin debug information in development mode\n   */\n  log(pluginName: string, message: string, data?: any): void {\n    if (process.env.NODE_ENV === 'development') {\n      console.group(`🔌 [${pluginName}]`)\n      console.log(message)\n      if (data) {\n        console.log('Data:', data)\n      }\n      console.groupEnd()\n    }\n  },\n\n  /**\n   * Creates a development-only warning\n   */\n  warn(pluginName: string, message: string): void {\n    if (process.env.NODE_ENV === 'development') {\n      console.warn(`⚠️  [${pluginName}] ${message}`)\n    }\n  },\n}"],"names":["validateSemver","version","compareSemver","a","b","parseVersion","main","prerelease","major","minor","patch","versionA","versionB","validatePluginName","name","normalizePluginName","PluginDevUtils","pluginName","message","data"],"mappings":"AAUO,SAASA,EAAeC,GAA0B;AACvD,SAAI,CAACA,KAAW,OAAOA,KAAY,WAC1B,KAIP,sLACiB,KAAKA,CAAO;AACjC;AAQO,SAASC,EAAcC,GAAWC,GAAmB;AAC1D,MAAI,CAACJ,EAAeG,CAAC,KAAK,CAACH,EAAeI,CAAC;AACzC,UAAM,IAAI,MAAM,iCAAiC;AAGnD,QAAMC,IAAe,CAACJ,MAAoB;AACxC,UAAM,CAACK,GAAMC,CAAU,IAAIN,EAAQ,MAAM,GAAG,GACtC,CAACO,GAAOC,GAAOC,CAAK,IAAIJ,EAAK,MAAM,GAAG,EAAE,IAAI,MAAM;AACxD,WAAO,EAAE,OAAAE,GAAO,OAAAC,GAAO,OAAAC,GAAO,YAAAH,EAAA;AAAA,EAChC,GAEMI,IAAWN,EAAaF,CAAC,GACzBS,IAAWP,EAAaD,CAAC;AAG/B,SAAIO,EAAS,UAAUC,EAAS,QACvBD,EAAS,QAAQC,EAAS,QAAQ,KAAK,IAI5CD,EAAS,UAAUC,EAAS,QACvBD,EAAS,QAAQC,EAAS,QAAQ,KAAK,IAI5CD,EAAS,UAAUC,EAAS,QACvBD,EAAS,QAAQC,EAAS,QAAQ,KAAK,IAI5CD,EAAS,cAAcC,EAAS,aAC3BD,EAAS,aAAaC,EAAS,aAClC,KACAD,EAAS,aAAaC,EAAS,aAC7B,IACA,IAIJD,EAAS,cAAc,CAACC,EAAS,aAAmB,KACpD,CAACD,EAAS,cAAcC,EAAS,aAAmB,IAEjD;AACT;AAKO,SAASC,EAAmBC,GAAuB;AACxD,SAAI,CAACA,KAAQ,OAAOA,KAAS,WACpB,KAIS,yDACD,KAAKA,CAAI;AAC5B;AAKO,SAASC,EAAoBD,GAAsB;AACxD,SAAOA,EAAK,QAAQ,aAAa,EAAE;AACrC;AAKO,MAAME,IAAiB;AAAA;AAAA;AAAA;AAAA,EAI5B,IAAIC,GAAoBC,GAAiBC,GAAkB;AACzD,IAAI,QAAQ,IAAI,aAAa,kBAC3B,QAAQ,MAAM,OAAOF,CAAU,GAAG,GAClC,QAAQ,IAAIC,CAAO,GACfC,KACF,QAAQ,IAAI,SAASA,CAAI,GAE3B,QAAQ,SAAA;AAAA,EAEZ;AAAA;AAAA;AAAA;AAAA,EAKA,KAAKF,GAAoBC,GAAuB;AAC9C,IAAI,QAAQ,IAAI,aAAa,iBAC3B,QAAQ,KAAK,QAAQD,CAAU,KAAKC,CAAO,EAAE;AAAA,EAEjD;AACF;"}

package/dist/reactive/cleanup.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./context.cjs");function r(e){const n=s.getCurrentOwner();n&&!n.disposed?n.cleanups.push(e):__DEV__&&console.warn("onCleanup called outside of reactive context")}function c(e){"dispose"in e&&typeof e.dispose=="function"&&e.dispose()}function i(e){const[n,t]=e();return r(t),n}function u(){const e=[];let n=!1;return{add(t){if(n){__DEV__&&console.warn("Adding cleanup to disposed group");return}e.push(t)},dispose(){if(!n){n=!0;for(const t of e)try{t()}catch(o){console.error("Error in cleanup function:",o)}e.length=0}},get disposed(){return n}}}function a(e,n){const t=setTimeout(e,n);return r(()=>clearTimeout(t)),t}function l(e,n){const t=setInterval(e,n);return r(()=>clearInterval(t)),t}function p(e,n,t,o){e.addEventListener(n,t,o),r(()=>e.removeEventListener(n,t,o))}typeof globalThis.__DEV__>"u"&&(globalThis.__DEV__=process.env.NODE_ENV!=="production");exports.createCleanupGroup=u;exports.createEventListener=p;exports.createInterval=l;exports.createResource=i;exports.createTimeout=a;exports.dispose=c;exports.onCleanup=r;
-//# sourceMappingURL=cleanup.cjs.map

package/dist/reactive/cleanup.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"cleanup.cjs","sources":["../../src/reactive/cleanup.ts"],"sourcesContent":["/**\n * Cleanup and disposal utilities for reactive system\n *\n * Provides memory management, cleanup functions, and disposal\n * utilities to prevent memory leaks in reactive computations.\n */\n\nimport { getCurrentOwner } from './context'\nimport type { CleanupFunction, Owner } from './types'\n\n/**\n * Add a cleanup function to the current reactive context\n *\n * @param fn Cleanup function to run when the context is disposed\n *\n * @example\n * ```typescript\n * createEffect(() => {\n *   const interval = setInterval(() => {\n *     console.log('tick')\n *   }, 1000)\n *\n *   onCleanup(() => {\n *     clearInterval(interval)\n *   })\n * })\n * ```\n */\nexport function onCleanup(fn: CleanupFunction): void {\n  const owner = getCurrentOwner()\n  if (owner && !owner.disposed) {\n    owner.cleanups.push(fn)\n  } else if (__DEV__) {\n    console.warn('onCleanup called outside of reactive context')\n  }\n}\n\n/**\n * Dispose a reactive owner and all its children\n *\n * @param owner The owner to dispose\n */\nexport function dispose(owner: Owner): void {\n  if ('dispose' in owner && typeof owner.dispose === 'function') {\n    owner.dispose()\n  }\n}\n\n/**\n * Create a disposable resource with automatic cleanup\n *\n * @param fn Function that creates and returns a resource and its cleanup\n * @returns The created resource\n *\n * @example\n * ```typescript\n * const timer = createResource(() => {\n *   const id = setInterval(() => console.log('tick'), 1000)\n *   return [id, () => clearInterval(id)]\n * })\n * ```\n */\nexport function createResource<T>(fn: () => [T, CleanupFunction]): T {\n  const [resource, cleanup] = fn()\n  onCleanup(cleanup)\n  return resource\n}\n\n/**\n * Create a cleanup group that can be disposed manually\n *\n * @returns Cleanup group with dispose function\n *\n * @example\n * ```typescript\n * const group = createCleanupGroup()\n *\n * group.add(() => console.log('cleanup 1'))\n * group.add(() => console.log('cleanup 2'))\n *\n * // Later...\n * group.dispose() // Runs both cleanup functions\n * ```\n */\nexport function createCleanupGroup(): {\n  add: (fn: CleanupFunction) => void\n  dispose: () => void\n  disposed: boolean\n} {\n  const cleanups: CleanupFunction[] = []\n  let disposed = false\n\n  return {\n    add(fn: CleanupFunction) {\n      if (disposed) {\n        if (__DEV__) {\n          console.warn('Adding cleanup to disposed group')\n        }\n        return\n      }\n      cleanups.push(fn)\n    },\n\n    dispose() {\n      if (disposed) return\n      disposed = true\n\n      for (const cleanup of cleanups) {\n        try {\n          cleanup()\n        } catch (error) {\n          console.error('Error in cleanup function:', error)\n        }\n      }\n      cleanups.length = 0\n    },\n\n    get disposed() {\n      return disposed\n    },\n  }\n}\n\n/**\n * Create a weak disposal tracker using WeakRef and FinalizationRegistry\n * for automatic cleanup of unreferenced objects\n */\nexport function createWeakDisposal<T extends object>(\n  target: T,\n  cleanup: CleanupFunction\n): WeakRef<T> {\n  const weakRef = new WeakRef(target)\n\n  if (typeof FinalizationRegistry !== 'undefined') {\n    const registry = new FinalizationRegistry(cleanup)\n    registry.register(target, cleanup)\n  }\n\n  return weakRef\n}\n\n/**\n * Defer a cleanup function to run after the current reactive cycle\n *\n * @param fn Cleanup function to defer\n */\nexport function deferCleanup(fn: CleanupFunction): void {\n  queueMicrotask(() => {\n    try {\n      fn()\n    } catch (error) {\n      console.error('Error in deferred cleanup:', error)\n    }\n  })\n}\n\n/**\n * Create a cleanup function that only runs once\n *\n * @param fn Cleanup function\n * @returns Cleanup function that only runs once\n */\nexport function createOnceCleanup(fn: CleanupFunction): CleanupFunction {\n  let hasRun = false\n\n  return () => {\n    if (hasRun) return\n    hasRun = true\n    fn()\n  }\n}\n\n/**\n * Create a timeout with automatic cleanup\n *\n * @param fn Function to run after timeout\n * @param delay Delay in milliseconds\n * @returns Timeout ID\n */\nexport function createTimeout(fn: () => void, delay: number): NodeJS.Timeout {\n  const id = setTimeout(fn, delay)\n  onCleanup(() => clearTimeout(id))\n  return id\n}\n\n/**\n * Create an interval with automatic cleanup\n *\n * @param fn Function to run on interval\n * @param delay Delay in milliseconds\n * @returns Interval ID\n */\nexport function createInterval(fn: () => void, delay: number): NodeJS.Timeout {\n  const id = setInterval(fn, delay)\n  onCleanup(() => clearInterval(id))\n  return id\n}\n\n/**\n * Create an event listener with automatic cleanup\n *\n * @param target Event target\n * @param event Event name\n * @param handler Event handler\n * @param options Event listener options\n */\nexport function createEventListener<K extends keyof WindowEventMap>(\n  target: Window,\n  event: K,\n  handler: (event: WindowEventMap[K]) => void,\n  options?: AddEventListenerOptions\n): void\nexport function createEventListener<K extends keyof DocumentEventMap>(\n  target: Document,\n  event: K,\n  handler: (event: DocumentEventMap[K]) => void,\n  options?: AddEventListenerOptions\n): void\nexport function createEventListener<K extends keyof HTMLElementEventMap>(\n  target: HTMLElement,\n  event: K,\n  handler: (event: HTMLElementEventMap[K]) => void,\n  options?: AddEventListenerOptions\n): void\nexport function createEventListener(\n  target: EventTarget,\n  event: string,\n  handler: (event: Event) => void,\n  options?: AddEventListenerOptions\n): void {\n  target.addEventListener(event, handler, options)\n  onCleanup(() => target.removeEventListener(event, handler, options))\n}\n\n// Development mode flag - simplified approach\nif (typeof (globalThis as any).__DEV__ === 'undefined') {\n  ;(globalThis as any).__DEV__ = process.env.NODE_ENV !== 'production'\n}\n\n// Re-export types\nexport type { CleanupFunction }\n"],"names":["onCleanup","fn","owner","getCurrentOwner","dispose","createResource","resource","cleanup","createCleanupGroup","cleanups","disposed","error","createTimeout","delay","id","createInterval","createEventListener","target","event","handler","options"],"mappings":"iHA4BO,SAASA,EAAUC,EAA2B,CACnD,MAAMC,EAAQC,EAAAA,gBAAA,EACVD,GAAS,CAACA,EAAM,SAClBA,EAAM,SAAS,KAAKD,CAAE,EACb,SACT,QAAQ,KAAK,8CAA8C,CAE/D,CAOO,SAASG,EAAQF,EAAoB,CACtC,YAAaA,GAAS,OAAOA,EAAM,SAAY,YACjDA,EAAM,QAAA,CAEV,CAgBO,SAASG,EAAkBJ,EAAmC,CACnE,KAAM,CAACK,EAAUC,CAAO,EAAIN,EAAA,EAC5B,OAAAD,EAAUO,CAAO,EACVD,CACT,CAkBO,SAASE,GAId,CACA,MAAMC,EAA8B,CAAA,EACpC,IAAIC,EAAW,GAEf,MAAO,CACL,IAAIT,EAAqB,CACvB,GAAIS,EAAU,CACR,SACF,QAAQ,KAAK,kCAAkC,EAEjD,MACF,CACAD,EAAS,KAAKR,CAAE,CAClB,EAEA,SAAU,CACR,GAAI,CAAAS,EACJ,CAAAA,EAAW,GAEX,UAAWH,KAAWE,EACpB,GAAI,CACFF,EAAA,CACF,OAASI,EAAO,CACd,QAAQ,MAAM,6BAA8BA,CAAK,CACnD,CAEFF,EAAS,OAAS,EACpB,EAEA,IAAI,UAAW,CACb,OAAOC,CACT,CAAA,CAEJ,CA0DO,SAASE,EAAcX,EAAgBY,EAA+B,CAC3E,MAAMC,EAAK,WAAWb,EAAIY,CAAK,EAC/B,OAAAb,EAAU,IAAM,aAAac,CAAE,CAAC,EACzBA,CACT,CASO,SAASC,EAAed,EAAgBY,EAA+B,CAC5E,MAAMC,EAAK,YAAYb,EAAIY,CAAK,EAChC,OAAAb,EAAU,IAAM,cAAcc,CAAE,CAAC,EAC1BA,CACT,CA4BO,SAASE,EACdC,EACAC,EACAC,EACAC,EACM,CACNH,EAAO,iBAAiBC,EAAOC,EAASC,CAAO,EAC/CpB,EAAU,IAAMiB,EAAO,oBAAoBC,EAAOC,EAASC,CAAO,CAAC,CACrE,CAGI,OAAQ,WAAmB,QAAY,MACvC,WAAmB,QAAU,QAAQ,IAAI,WAAa"}

package/dist/reactive/cleanup.js

@@ -1,62 +0,0 @@
-import { getCurrentOwner as s } from "./context.js";
-function r(e) {
-  const n = s();
-  n && !n.disposed ? n.cleanups.push(e) : __DEV__ && console.warn("onCleanup called outside of reactive context");
-}
-function c(e) {
-  "dispose" in e && typeof e.dispose == "function" && e.dispose();
-}
-function u(e) {
-  const [n, o] = e();
-  return r(o), n;
-}
-function a() {
-  const e = [];
-  let n = !1;
-  return {
-    add(o) {
-      if (n) {
-        __DEV__ && console.warn("Adding cleanup to disposed group");
-        return;
-      }
-      e.push(o);
-    },
-    dispose() {
-      if (!n) {
-        n = !0;
-        for (const o of e)
-          try {
-            o();
-          } catch (t) {
-            console.error("Error in cleanup function:", t);
-          }
-        e.length = 0;
-      }
-    },
-    get disposed() {
-      return n;
-    }
-  };
-}
-function p(e, n) {
-  const o = setTimeout(e, n);
-  return r(() => clearTimeout(o)), o;
-}
-function l(e, n) {
-  const o = setInterval(e, n);
-  return r(() => clearInterval(o)), o;
-}
-function d(e, n, o, t) {
-  e.addEventListener(n, o, t), r(() => e.removeEventListener(n, o, t));
-}
-typeof globalThis.__DEV__ > "u" && (globalThis.__DEV__ = process.env.NODE_ENV !== "production");
-export {
-  a as createCleanupGroup,
-  d as createEventListener,
-  l as createInterval,
-  u as createResource,
-  p as createTimeout,
-  c as dispose,
-  r as onCleanup
-};
-//# sourceMappingURL=cleanup.js.map

package/dist/reactive/cleanup.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cleanup.js","sources":["../../src/reactive/cleanup.ts"],"sourcesContent":["/**\n * Cleanup and disposal utilities for reactive system\n *\n * Provides memory management, cleanup functions, and disposal\n * utilities to prevent memory leaks in reactive computations.\n */\n\nimport { getCurrentOwner } from './context'\nimport type { CleanupFunction, Owner } from './types'\n\n/**\n * Add a cleanup function to the current reactive context\n *\n * @param fn Cleanup function to run when the context is disposed\n *\n * @example\n * ```typescript\n * createEffect(() => {\n *   const interval = setInterval(() => {\n *     console.log('tick')\n *   }, 1000)\n *\n *   onCleanup(() => {\n *     clearInterval(interval)\n *   })\n * })\n * ```\n */\nexport function onCleanup(fn: CleanupFunction): void {\n  const owner = getCurrentOwner()\n  if (owner && !owner.disposed) {\n    owner.cleanups.push(fn)\n  } else if (__DEV__) {\n    console.warn('onCleanup called outside of reactive context')\n  }\n}\n\n/**\n * Dispose a reactive owner and all its children\n *\n * @param owner The owner to dispose\n */\nexport function dispose(owner: Owner): void {\n  if ('dispose' in owner && typeof owner.dispose === 'function') {\n    owner.dispose()\n  }\n}\n\n/**\n * Create a disposable resource with automatic cleanup\n *\n * @param fn Function that creates and returns a resource and its cleanup\n * @returns The created resource\n *\n * @example\n * ```typescript\n * const timer = createResource(() => {\n *   const id = setInterval(() => console.log('tick'), 1000)\n *   return [id, () => clearInterval(id)]\n * })\n * ```\n */\nexport function createResource<T>(fn: () => [T, CleanupFunction]): T {\n  const [resource, cleanup] = fn()\n  onCleanup(cleanup)\n  return resource\n}\n\n/**\n * Create a cleanup group that can be disposed manually\n *\n * @returns Cleanup group with dispose function\n *\n * @example\n * ```typescript\n * const group = createCleanupGroup()\n *\n * group.add(() => console.log('cleanup 1'))\n * group.add(() => console.log('cleanup 2'))\n *\n * // Later...\n * group.dispose() // Runs both cleanup functions\n * ```\n */\nexport function createCleanupGroup(): {\n  add: (fn: CleanupFunction) => void\n  dispose: () => void\n  disposed: boolean\n} {\n  const cleanups: CleanupFunction[] = []\n  let disposed = false\n\n  return {\n    add(fn: CleanupFunction) {\n      if (disposed) {\n        if (__DEV__) {\n          console.warn('Adding cleanup to disposed group')\n        }\n        return\n      }\n      cleanups.push(fn)\n    },\n\n    dispose() {\n      if (disposed) return\n      disposed = true\n\n      for (const cleanup of cleanups) {\n        try {\n          cleanup()\n        } catch (error) {\n          console.error('Error in cleanup function:', error)\n        }\n      }\n      cleanups.length = 0\n    },\n\n    get disposed() {\n      return disposed\n    },\n  }\n}\n\n/**\n * Create a weak disposal tracker using WeakRef and FinalizationRegistry\n * for automatic cleanup of unreferenced objects\n */\nexport function createWeakDisposal<T extends object>(\n  target: T,\n  cleanup: CleanupFunction\n): WeakRef<T> {\n  const weakRef = new WeakRef(target)\n\n  if (typeof FinalizationRegistry !== 'undefined') {\n    const registry = new FinalizationRegistry(cleanup)\n    registry.register(target, cleanup)\n  }\n\n  return weakRef\n}\n\n/**\n * Defer a cleanup function to run after the current reactive cycle\n *\n * @param fn Cleanup function to defer\n */\nexport function deferCleanup(fn: CleanupFunction): void {\n  queueMicrotask(() => {\n    try {\n      fn()\n    } catch (error) {\n      console.error('Error in deferred cleanup:', error)\n    }\n  })\n}\n\n/**\n * Create a cleanup function that only runs once\n *\n * @param fn Cleanup function\n * @returns Cleanup function that only runs once\n */\nexport function createOnceCleanup(fn: CleanupFunction): CleanupFunction {\n  let hasRun = false\n\n  return () => {\n    if (hasRun) return\n    hasRun = true\n    fn()\n  }\n}\n\n/**\n * Create a timeout with automatic cleanup\n *\n * @param fn Function to run after timeout\n * @param delay Delay in milliseconds\n * @returns Timeout ID\n */\nexport function createTimeout(fn: () => void, delay: number): NodeJS.Timeout {\n  const id = setTimeout(fn, delay)\n  onCleanup(() => clearTimeout(id))\n  return id\n}\n\n/**\n * Create an interval with automatic cleanup\n *\n * @param fn Function to run on interval\n * @param delay Delay in milliseconds\n * @returns Interval ID\n */\nexport function createInterval(fn: () => void, delay: number): NodeJS.Timeout {\n  const id = setInterval(fn, delay)\n  onCleanup(() => clearInterval(id))\n  return id\n}\n\n/**\n * Create an event listener with automatic cleanup\n *\n * @param target Event target\n * @param event Event name\n * @param handler Event handler\n * @param options Event listener options\n */\nexport function createEventListener<K extends keyof WindowEventMap>(\n  target: Window,\n  event: K,\n  handler: (event: WindowEventMap[K]) => void,\n  options?: AddEventListenerOptions\n): void\nexport function createEventListener<K extends keyof DocumentEventMap>(\n  target: Document,\n  event: K,\n  handler: (event: DocumentEventMap[K]) => void,\n  options?: AddEventListenerOptions\n): void\nexport function createEventListener<K extends keyof HTMLElementEventMap>(\n  target: HTMLElement,\n  event: K,\n  handler: (event: HTMLElementEventMap[K]) => void,\n  options?: AddEventListenerOptions\n): void\nexport function createEventListener(\n  target: EventTarget,\n  event: string,\n  handler: (event: Event) => void,\n  options?: AddEventListenerOptions\n): void {\n  target.addEventListener(event, handler, options)\n  onCleanup(() => target.removeEventListener(event, handler, options))\n}\n\n// Development mode flag - simplified approach\nif (typeof (globalThis as any).__DEV__ === 'undefined') {\n  ;(globalThis as any).__DEV__ = process.env.NODE_ENV !== 'production'\n}\n\n// Re-export types\nexport type { CleanupFunction }\n"],"names":["onCleanup","fn","owner","getCurrentOwner","dispose","createResource","resource","cleanup","createCleanupGroup","cleanups","disposed","error","createTimeout","delay","id","createInterval","createEventListener","target","event","handler","options"],"mappings":";AA4BO,SAASA,EAAUC,GAA2B;AACnD,QAAMC,IAAQC,EAAA;AACd,EAAID,KAAS,CAACA,EAAM,WAClBA,EAAM,SAAS,KAAKD,CAAE,IACb,WACT,QAAQ,KAAK,8CAA8C;AAE/D;AAOO,SAASG,EAAQF,GAAoB;AAC1C,EAAI,aAAaA,KAAS,OAAOA,EAAM,WAAY,cACjDA,EAAM,QAAA;AAEV;AAgBO,SAASG,EAAkBJ,GAAmC;AACnE,QAAM,CAACK,GAAUC,CAAO,IAAIN,EAAA;AAC5B,SAAAD,EAAUO,CAAO,GACVD;AACT;AAkBO,SAASE,IAId;AACA,QAAMC,IAA8B,CAAA;AACpC,MAAIC,IAAW;AAEf,SAAO;AAAA,IACL,IAAIT,GAAqB;AACvB,UAAIS,GAAU;AACZ,QAAI,WACF,QAAQ,KAAK,kCAAkC;AAEjD;AAAA,MACF;AACA,MAAAD,EAAS,KAAKR,CAAE;AAAA,IAClB;AAAA,IAEA,UAAU;AACR,UAAI,CAAAS,GACJ;AAAA,QAAAA,IAAW;AAEX,mBAAWH,KAAWE;AACpB,cAAI;AACF,YAAAF,EAAA;AAAA,UACF,SAASI,GAAO;AACd,oBAAQ,MAAM,8BAA8BA,CAAK;AAAA,UACnD;AAEF,QAAAF,EAAS,SAAS;AAAA;AAAA,IACpB;AAAA,IAEA,IAAI,WAAW;AACb,aAAOC;AAAA,IACT;AAAA,EAAA;AAEJ;AA0DO,SAASE,EAAcX,GAAgBY,GAA+B;AAC3E,QAAMC,IAAK,WAAWb,GAAIY,CAAK;AAC/B,SAAAb,EAAU,MAAM,aAAac,CAAE,CAAC,GACzBA;AACT;AASO,SAASC,EAAed,GAAgBY,GAA+B;AAC5E,QAAMC,IAAK,YAAYb,GAAIY,CAAK;AAChC,SAAAb,EAAU,MAAM,cAAcc,CAAE,CAAC,GAC1BA;AACT;AA4BO,SAASE,EACdC,GACAC,GACAC,GACAC,GACM;AACN,EAAAH,EAAO,iBAAiBC,GAAOC,GAASC,CAAO,GAC/CpB,EAAU,MAAMiB,EAAO,oBAAoBC,GAAOC,GAASC,CAAO,CAAC;AACrE;AAGI,OAAQ,WAAmB,UAAY,QACvC,WAAmB,UAAU,QAAQ,IAAI,aAAa;"}

package/dist/reactive/computed.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("./context.cjs"),l=require("./equality.cjs"),i=require("./types.cjs"),n=require("./unified-scheduler.cjs");var c=Object.defineProperty,h=(s,e,t)=>e in s?c(s,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):s[e]=t,o=(s,e,t)=>h(s,typeof e!="symbol"?e+"":e,t);class p extends a.ComputationImpl{constructor(e,t={},r=a.getCurrentOwner()){super(e,r),o(this,"type","computed"),o(this,"priority"),o(this,"_hasValue",!1),o(this,"_error",null),o(this,"equalsFn"),o(this,"options"),this.priority=t.priority??n.UpdatePriority.Normal,this.equalsFn=t.equals??l.defaultEquals,this.options=t}getValue(){const e=a.getCurrentComputation();return e&&e.state!==i.ComputationState.Disposed&&(this.observers.add(e),e.sources.add(this)),(this.state===i.ComputationState.Dirty||!this._hasValue)&&(this.execute(),this._hasValue=!0),this.value}peek(){return(this.state===i.ComputationState.Dirty||!this._hasValue)&&(this.execute(),this._hasValue=!0),this.value}removeObserver(e){this.observers.delete(e)}execute(){const e=this._hasValue?this.value:void 0,t=super.execute();if(!this._hasValue||!this.equalsFn(e,t))for(const r of this.observers)r.state!==i.ComputationState.Disposed&&(r.state=i.ComputationState.Dirty,"execute"in r&&typeof r.execute=="function"&&queueMicrotask(()=>{r.state===i.ComputationState.Dirty&&r.execute()}));return t}notify(){this.execute()}cleanup(){for(const e of this.sources)"removeObserver"in e&&e.removeObserver(this);this.sources.clear();for(const e of this.observers)e.sources.delete(this);this.observers.clear(),this._hasValue=!1,this._error=null,this.state=i.ComputationState.Disposed}dispose(){this.cleanup(),super.dispose()}[Symbol.for("tachui.debug")](){return{id:this.id,type:this.type,value:this._hasValue?this.value:void 0,hasValue:this._hasValue,error:this._error?.message,state:this.state,sourceCount:this.sources.size,observerCount:this.observers.size,priority:n.UpdatePriority[this.priority],debugName:this.options.debugName,equalsFn:this.equalsFn.name||"anonymous"}}toString(){return`Computed(${this.options.debugName||this.id}): ${this._hasValue?this.value:"no value"}`}}function u(s,e){const t=new p(s,e),r=t.getValue.bind(t);return r.peek=t.peek.bind(t),Object.defineProperty(r,Symbol.for("tachui.computed"),{value:t,enumerable:!1}),r}function d(s,e){return u(s,e)}function m(s){return typeof s=="function"&&Symbol.for("tachui.computed")in s}function f(s){return s[Symbol.for("tachui.computed")]||null}function b(s,e){return u(e?()=>{for(const r of e)r();return s()}:s)}function v(s,e){let t,r=!1;return u(()=>(e()&&(t=s(),r=!0),r||(t=s(),r=!0),t))}exports.createComputed=u;exports.createConditionalComputed=v;exports.createDerivedSignal=b;exports.createMemo=d;exports.getComputedImpl=f;exports.isComputed=m;
-//# sourceMappingURL=computed.cjs.map

package/dist/reactive/computed.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed.cjs","sources":["../../src/reactive/computed.ts"],"sourcesContent":["/**\n * Computed values implementation\n *\n * Computed values are derived reactive values that automatically\n * update when their dependencies change, with memoization.\n */\n\nimport { ComputationImpl, getCurrentComputation, getCurrentOwner } from './context'\nimport { defaultEquals, type EqualityFunction } from './equality'\nimport type { Computation, Signal } from './types'\nimport { ComputationState } from './types'\nimport { type ReactiveNode, UpdatePriority } from './unified-scheduler'\n\nexport interface ComputedOptions<T> {\n  equals?: EqualityFunction<T>\n  priority?: UpdatePriority\n  debugName?: string\n  onError?: (error: Error) => T // Error recovery function\n}\n\n/**\n * Robust computed value implementation with error recovery\n */\nclass ComputedImpl<T> extends ComputationImpl implements ReactiveNode {\n  readonly type = 'computed' as const\n  readonly priority: UpdatePriority\n\n  private _hasValue = false\n  private _error: Error | null = null\n  private equalsFn: EqualityFunction<T>\n  private options: ComputedOptions<T>\n\n  constructor(fn: () => T, options: ComputedOptions<T> = {}, owner = getCurrentOwner()) {\n    super(fn, owner)\n    this.priority = options.priority ?? UpdatePriority.Normal\n    this.equalsFn = options.equals ?? defaultEquals\n    this.options = options\n  }\n\n  /**\n   * Get the computed value, tracking dependency and lazily computing\n   */\n  getValue(): T {\n    // Track this computed as a dependency if we're in a reactive context\n    const computation = getCurrentComputation()\n    if (computation && computation.state !== ComputationState.Disposed) {\n      this.observers.add(computation)\n      computation.sources.add(this)\n    }\n\n    // Compute value if needed\n    if (this.state === ComputationState.Dirty || !this._hasValue) {\n      this.execute()\n      this._hasValue = true\n    }\n\n    return this.value\n  }\n\n  /**\n   * Get the current value without tracking dependency\n   */\n  peek(): T {\n    if (this.state === ComputationState.Dirty || !this._hasValue) {\n      this.execute()\n      this._hasValue = true\n    }\n    return this.value\n  }\n\n  /**\n   * Remove an observer (cleanup)\n   */\n  removeObserver(computation: Computation): void {\n    this.observers.delete(computation)\n  }\n\n  /**\n   * Execute the computation and notify observers\n   */\n  execute(): T {\n    const previousValue = this._hasValue ? this.value : undefined\n    const result = super.execute()\n\n    // Only notify observers if the value actually changed\n    if (!this._hasValue || !this.equalsFn(previousValue, result)) {\n      // Notify dependent computations\n      for (const observer of this.observers) {\n        if (observer.state !== ComputationState.Disposed) {\n          observer.state = ComputationState.Dirty\n          // Use the signal's scheduling mechanism for consistency\n          if ('execute' in observer && typeof observer.execute === 'function') {\n            queueMicrotask(() => {\n              if (observer.state === ComputationState.Dirty) {\n                observer.execute()\n              }\n            })\n          }\n        }\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * Notify method for ReactiveNode compatibility\n   */\n  notify(): void {\n    // For computations, notify means execute\n    this.execute()\n  }\n\n  /**\n   * Complete cleanup for memory management\n   */\n  cleanup(): void {\n    // Complete bidirectional cleanup\n    for (const source of this.sources) {\n      if ('removeObserver' in source) {\n        ;(source as any).removeObserver(this)\n      }\n    }\n    this.sources.clear()\n\n    for (const observer of this.observers) {\n      observer.sources.delete(this)\n    }\n    this.observers.clear()\n\n    this._hasValue = false\n    this._error = null\n    this.state = ComputationState.Disposed\n  }\n\n  /**\n   * Dispose the computed value\n   */\n  dispose(): void {\n    this.cleanup()\n    super.dispose()\n  }\n\n  /**\n   * Debug information\n   */\n  [Symbol.for('tachui.debug')](): object {\n    return {\n      id: this.id,\n      type: this.type,\n      value: this._hasValue ? this.value : undefined,\n      hasValue: this._hasValue,\n      error: this._error?.message,\n      state: this.state,\n      sourceCount: this.sources.size,\n      observerCount: this.observers.size,\n      priority: UpdatePriority[this.priority],\n      debugName: this.options.debugName,\n      equalsFn: this.equalsFn.name || 'anonymous',\n    }\n  }\n\n  toString(): string {\n    return `Computed(${this.options.debugName || this.id}): ${this._hasValue ? this.value : 'no value'}`\n  }\n}\n\n/**\n * Create a computed value that automatically updates when dependencies change\n *\n * @param fn The computation function\n * @param options Configuration options for the computed value\n * @returns An accessor function for the computed value\n *\n * @example\n * ```typescript\n * const [count, setCount] = createSignal(0)\n * const doubleCount = createComputed(() => count() * 2, {\n *   debugName: 'doubleCounter',\n *   onError: (error) => {\n *     console.error('Computation failed:', error)\n *     return 0 // fallback value\n *   }\n * })\n *\n * console.log(doubleCount()) // 0\n * setCount(5)\n * console.log(doubleCount()) // 10\n * ```\n */\nexport function createComputed<T>(fn: () => T, options?: ComputedOptions<T>): Signal<T> {\n  const computed = new ComputedImpl(fn, options)\n\n  // Create bound accessor with peek method - this is already a Signal<T>\n  const accessor = computed.getValue.bind(computed) as Signal<T>\n  accessor.peek = computed.peek.bind(computed)\n\n  // Add debug information\n  Object.defineProperty(accessor, Symbol.for('tachui.computed'), {\n    value: computed,\n    enumerable: false,\n  })\n\n  return accessor\n}\n\n/**\n * Create a memo (alias for createComputed for SolidJS compatibility)\n */\nexport function createMemo<T>(fn: () => T, options?: ComputedOptions<T>): Signal<T> {\n  return createComputed(fn, options)\n}\n\n/**\n * Type guard to check if a value is a computed\n */\nexport function isComputed<T = any>(value: any): value is Signal<T> {\n  return typeof value === 'function' && Symbol.for('tachui.computed') in value\n}\n\n/**\n * Get the underlying computed implementation for debugging\n */\nexport function getComputedImpl<T>(computed: Signal<T>): ComputedImpl<T> | null {\n  return (computed as any)[Symbol.for('tachui.computed')] || null\n}\n\n/**\n * Create a computed value with explicit dependency tracking\n *\n * @param fn The computation function\n * @param deps Explicit dependencies (optional)\n * @returns An accessor function for the computed value\n */\nexport function createDerivedSignal<T>(fn: () => T, deps?: (() => any)[]): Signal<T> {\n  if (!deps) {\n    return createComputed(fn)\n  }\n\n  // Wrap function to explicitly track dependencies\n  const wrappedFn = () => {\n    // Read all dependencies to track them\n    for (const dep of deps) {\n      dep()\n    }\n    return fn()\n  }\n\n  return createComputed(wrappedFn)\n}\n\n/**\n * Create a computed value that only updates when a condition is met\n *\n * @param fn The computation function\n * @param when Condition function that must return true for updates\n * @returns An accessor function for the computed value\n */\nexport function createConditionalComputed<T>(fn: () => T, when: () => boolean): Signal<T> {\n  let lastValue: T\n  let hasValue = false\n\n  return createComputed(() => {\n    if (when()) {\n      lastValue = fn()\n      hasValue = true\n    }\n\n    if (!hasValue) {\n      lastValue = fn()\n      hasValue = true\n    }\n\n    return lastValue\n  })\n}\n\n/**\n * Public Computed type export\n */\nexport type Computed<T> = Signal<T>\n"],"names":["ComputedImpl","ComputationImpl","fn","options","owner","getCurrentOwner","__publicField","UpdatePriority","defaultEquals","computation","getCurrentComputation","ComputationState","previousValue","result","observer","source","createComputed","computed","accessor","createMemo","isComputed","value","getComputedImpl","createDerivedSignal","deps","dep","createConditionalComputed","when","lastValue","hasValue"],"mappings":"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"}

package/dist/reactive/computed.js

@@ -1,121 +0,0 @@
-import { ComputationImpl as n, getCurrentOwner as h, getCurrentComputation as l } from "./context.js";
-import { defaultEquals as c } from "./equality.js";
-import { ComputationState as i } from "./types.js";
-import { UpdatePriority as a } from "./unified-scheduler.js";
-var p = Object.defineProperty, f = (s, e, t) => e in s ? p(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, o = (s, e, t) => f(s, typeof e != "symbol" ? e + "" : e, t);
-class d extends n {
-  constructor(e, t = {}, r = h()) {
-    super(e, r), o(this, "type", "computed"), o(this, "priority"), o(this, "_hasValue", !1), o(this, "_error", null), o(this, "equalsFn"), o(this, "options"), this.priority = t.priority ?? a.Normal, this.equalsFn = t.equals ?? c, this.options = t;
-  }
-  /**
-   * Get the computed value, tracking dependency and lazily computing
-   */
-  getValue() {
-    const e = l();
-    return e && e.state !== i.Disposed && (this.observers.add(e), e.sources.add(this)), (this.state === i.Dirty || !this._hasValue) && (this.execute(), this._hasValue = !0), this.value;
-  }
-  /**
-   * Get the current value without tracking dependency
-   */
-  peek() {
-    return (this.state === i.Dirty || !this._hasValue) && (this.execute(), this._hasValue = !0), this.value;
-  }
-  /**
-   * Remove an observer (cleanup)
-   */
-  removeObserver(e) {
-    this.observers.delete(e);
-  }
-  /**
-   * Execute the computation and notify observers
-   */
-  execute() {
-    const e = this._hasValue ? this.value : void 0, t = super.execute();
-    if (!this._hasValue || !this.equalsFn(e, t))
-      for (const r of this.observers)
-        r.state !== i.Disposed && (r.state = i.Dirty, "execute" in r && typeof r.execute == "function" && queueMicrotask(() => {
-          r.state === i.Dirty && r.execute();
-        }));
-    return t;
-  }
-  /**
-   * Notify method for ReactiveNode compatibility
-   */
-  notify() {
-    this.execute();
-  }
-  /**
-   * Complete cleanup for memory management
-   */
-  cleanup() {
-    for (const e of this.sources)
-      "removeObserver" in e && e.removeObserver(this);
-    this.sources.clear();
-    for (const e of this.observers)
-      e.sources.delete(this);
-    this.observers.clear(), this._hasValue = !1, this._error = null, this.state = i.Disposed;
-  }
-  /**
-   * Dispose the computed value
-   */
-  dispose() {
-    this.cleanup(), super.dispose();
-  }
-  /**
-   * Debug information
-   */
-  [Symbol.for("tachui.debug")]() {
-    return {
-      id: this.id,
-      type: this.type,
-      value: this._hasValue ? this.value : void 0,
-      hasValue: this._hasValue,
-      error: this._error?.message,
-      state: this.state,
-      sourceCount: this.sources.size,
-      observerCount: this.observers.size,
-      priority: a[this.priority],
-      debugName: this.options.debugName,
-      equalsFn: this.equalsFn.name || "anonymous"
-    };
-  }
-  toString() {
-    return `Computed(${this.options.debugName || this.id}): ${this._hasValue ? this.value : "no value"}`;
-  }
-}
-function u(s, e) {
-  const t = new d(s, e), r = t.getValue.bind(t);
-  return r.peek = t.peek.bind(t), Object.defineProperty(r, Symbol.for("tachui.computed"), {
-    value: t,
-    enumerable: !1
-  }), r;
-}
-function _(s, e) {
-  return u(s, e);
-}
-function V(s) {
-  return typeof s == "function" && Symbol.for("tachui.computed") in s;
-}
-function C(s) {
-  return s[Symbol.for("tachui.computed")] || null;
-}
-function g(s, e) {
-  return u(e ? () => {
-    for (const r of e)
-      r();
-    return s();
-  } : s);
-}
-function x(s, e) {
-  let t, r = !1;
-  return u(() => (e() && (t = s(), r = !0), r || (t = s(), r = !0), t));
-}
-export {
-  u as createComputed,
-  x as createConditionalComputed,
-  g as createDerivedSignal,
-  _ as createMemo,
-  C as getComputedImpl,
-  V as isComputed
-};
-//# sourceMappingURL=computed.js.map

package/dist/reactive/computed.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed.js","sources":["../../src/reactive/computed.ts"],"sourcesContent":["/**\n * Computed values implementation\n *\n * Computed values are derived reactive values that automatically\n * update when their dependencies change, with memoization.\n */\n\nimport { ComputationImpl, getCurrentComputation, getCurrentOwner } from './context'\nimport { defaultEquals, type EqualityFunction } from './equality'\nimport type { Computation, Signal } from './types'\nimport { ComputationState } from './types'\nimport { type ReactiveNode, UpdatePriority } from './unified-scheduler'\n\nexport interface ComputedOptions<T> {\n  equals?: EqualityFunction<T>\n  priority?: UpdatePriority\n  debugName?: string\n  onError?: (error: Error) => T // Error recovery function\n}\n\n/**\n * Robust computed value implementation with error recovery\n */\nclass ComputedImpl<T> extends ComputationImpl implements ReactiveNode {\n  readonly type = 'computed' as const\n  readonly priority: UpdatePriority\n\n  private _hasValue = false\n  private _error: Error | null = null\n  private equalsFn: EqualityFunction<T>\n  private options: ComputedOptions<T>\n\n  constructor(fn: () => T, options: ComputedOptions<T> = {}, owner = getCurrentOwner()) {\n    super(fn, owner)\n    this.priority = options.priority ?? UpdatePriority.Normal\n    this.equalsFn = options.equals ?? defaultEquals\n    this.options = options\n  }\n\n  /**\n   * Get the computed value, tracking dependency and lazily computing\n   */\n  getValue(): T {\n    // Track this computed as a dependency if we're in a reactive context\n    const computation = getCurrentComputation()\n    if (computation && computation.state !== ComputationState.Disposed) {\n      this.observers.add(computation)\n      computation.sources.add(this)\n    }\n\n    // Compute value if needed\n    if (this.state === ComputationState.Dirty || !this._hasValue) {\n      this.execute()\n      this._hasValue = true\n    }\n\n    return this.value\n  }\n\n  /**\n   * Get the current value without tracking dependency\n   */\n  peek(): T {\n    if (this.state === ComputationState.Dirty || !this._hasValue) {\n      this.execute()\n      this._hasValue = true\n    }\n    return this.value\n  }\n\n  /**\n   * Remove an observer (cleanup)\n   */\n  removeObserver(computation: Computation): void {\n    this.observers.delete(computation)\n  }\n\n  /**\n   * Execute the computation and notify observers\n   */\n  execute(): T {\n    const previousValue = this._hasValue ? this.value : undefined\n    const result = super.execute()\n\n    // Only notify observers if the value actually changed\n    if (!this._hasValue || !this.equalsFn(previousValue, result)) {\n      // Notify dependent computations\n      for (const observer of this.observers) {\n        if (observer.state !== ComputationState.Disposed) {\n          observer.state = ComputationState.Dirty\n          // Use the signal's scheduling mechanism for consistency\n          if ('execute' in observer && typeof observer.execute === 'function') {\n            queueMicrotask(() => {\n              if (observer.state === ComputationState.Dirty) {\n                observer.execute()\n              }\n            })\n          }\n        }\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * Notify method for ReactiveNode compatibility\n   */\n  notify(): void {\n    // For computations, notify means execute\n    this.execute()\n  }\n\n  /**\n   * Complete cleanup for memory management\n   */\n  cleanup(): void {\n    // Complete bidirectional cleanup\n    for (const source of this.sources) {\n      if ('removeObserver' in source) {\n        ;(source as any).removeObserver(this)\n      }\n    }\n    this.sources.clear()\n\n    for (const observer of this.observers) {\n      observer.sources.delete(this)\n    }\n    this.observers.clear()\n\n    this._hasValue = false\n    this._error = null\n    this.state = ComputationState.Disposed\n  }\n\n  /**\n   * Dispose the computed value\n   */\n  dispose(): void {\n    this.cleanup()\n    super.dispose()\n  }\n\n  /**\n   * Debug information\n   */\n  [Symbol.for('tachui.debug')](): object {\n    return {\n      id: this.id,\n      type: this.type,\n      value: this._hasValue ? this.value : undefined,\n      hasValue: this._hasValue,\n      error: this._error?.message,\n      state: this.state,\n      sourceCount: this.sources.size,\n      observerCount: this.observers.size,\n      priority: UpdatePriority[this.priority],\n      debugName: this.options.debugName,\n      equalsFn: this.equalsFn.name || 'anonymous',\n    }\n  }\n\n  toString(): string {\n    return `Computed(${this.options.debugName || this.id}): ${this._hasValue ? this.value : 'no value'}`\n  }\n}\n\n/**\n * Create a computed value that automatically updates when dependencies change\n *\n * @param fn The computation function\n * @param options Configuration options for the computed value\n * @returns An accessor function for the computed value\n *\n * @example\n * ```typescript\n * const [count, setCount] = createSignal(0)\n * const doubleCount = createComputed(() => count() * 2, {\n *   debugName: 'doubleCounter',\n *   onError: (error) => {\n *     console.error('Computation failed:', error)\n *     return 0 // fallback value\n *   }\n * })\n *\n * console.log(doubleCount()) // 0\n * setCount(5)\n * console.log(doubleCount()) // 10\n * ```\n */\nexport function createComputed<T>(fn: () => T, options?: ComputedOptions<T>): Signal<T> {\n  const computed = new ComputedImpl(fn, options)\n\n  // Create bound accessor with peek method - this is already a Signal<T>\n  const accessor = computed.getValue.bind(computed) as Signal<T>\n  accessor.peek = computed.peek.bind(computed)\n\n  // Add debug information\n  Object.defineProperty(accessor, Symbol.for('tachui.computed'), {\n    value: computed,\n    enumerable: false,\n  })\n\n  return accessor\n}\n\n/**\n * Create a memo (alias for createComputed for SolidJS compatibility)\n */\nexport function createMemo<T>(fn: () => T, options?: ComputedOptions<T>): Signal<T> {\n  return createComputed(fn, options)\n}\n\n/**\n * Type guard to check if a value is a computed\n */\nexport function isComputed<T = any>(value: any): value is Signal<T> {\n  return typeof value === 'function' && Symbol.for('tachui.computed') in value\n}\n\n/**\n * Get the underlying computed implementation for debugging\n */\nexport function getComputedImpl<T>(computed: Signal<T>): ComputedImpl<T> | null {\n  return (computed as any)[Symbol.for('tachui.computed')] || null\n}\n\n/**\n * Create a computed value with explicit dependency tracking\n *\n * @param fn The computation function\n * @param deps Explicit dependencies (optional)\n * @returns An accessor function for the computed value\n */\nexport function createDerivedSignal<T>(fn: () => T, deps?: (() => any)[]): Signal<T> {\n  if (!deps) {\n    return createComputed(fn)\n  }\n\n  // Wrap function to explicitly track dependencies\n  const wrappedFn = () => {\n    // Read all dependencies to track them\n    for (const dep of deps) {\n      dep()\n    }\n    return fn()\n  }\n\n  return createComputed(wrappedFn)\n}\n\n/**\n * Create a computed value that only updates when a condition is met\n *\n * @param fn The computation function\n * @param when Condition function that must return true for updates\n * @returns An accessor function for the computed value\n */\nexport function createConditionalComputed<T>(fn: () => T, when: () => boolean): Signal<T> {\n  let lastValue: T\n  let hasValue = false\n\n  return createComputed(() => {\n    if (when()) {\n      lastValue = fn()\n      hasValue = true\n    }\n\n    if (!hasValue) {\n      lastValue = fn()\n      hasValue = true\n    }\n\n    return lastValue\n  })\n}\n\n/**\n * Public Computed type export\n */\nexport type Computed<T> = Signal<T>\n"],"names":["ComputedImpl","ComputationImpl","fn","options","owner","getCurrentOwner","__publicField","UpdatePriority","defaultEquals","computation","getCurrentComputation","ComputationState","previousValue","result","observer","source","createComputed","computed","accessor","createMemo","isComputed","value","getComputedImpl","createDerivedSignal","deps","dep","createConditionalComputed","when","lastValue","hasValue"],"mappings":"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"}

package/dist/reactive/context.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=require("./types.cjs");var p=Object.defineProperty,f=(r,t,e)=>t in r?p(r,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):r[t]=e,s=(r,t,e)=>f(r,typeof t!="symbol"?t+"":t,e);let a=0,h=0,o=null,n=null,i=!1;function d(){return o}function m(){return n}function C(){return i}class v{constructor(t=null){s(this,"id"),s(this,"parent"),s(this,"context",new Map),s(this,"cleanups",[]),s(this,"sources",new Set),s(this,"disposed",!1),this.id=++h,this.parent=t}dispose(){if(!this.disposed){this.disposed=!0;for(const t of this.sources)t.dispose();this.sources.clear();for(const t of this.cleanups)try{t()}catch(e){console.error("Error in cleanup function:",e)}this.cleanups.length=0,this.parent&&!this.parent.disposed&&this.parent.sources.delete(this)}}}class l{constructor(t,e=null){s(this,"id"),s(this,"owner"),s(this,"fn"),s(this,"sources",new Set),s(this,"observers",new Set),s(this,"state",u.ComputationState.Dirty),s(this,"value"),this.id=++a,this.fn=t,this.owner=e,e&&!e.disposed&&e.sources.add(this)}execute(){if(this.state===u.ComputationState.Disposed)return this.value;for(const e of this.sources)e&&typeof e=="object"&&"removeObserver"in e&&e.removeObserver(this);this.sources.clear();const t=o;o=this;try{return this.state=u.ComputationState.Clean,this.value=this.fn(),this.value}catch(e){throw this.state=u.ComputationState.Disposed,(typeof process>"u"||process.env.NODE_ENV!=="test")&&console.error("Error in computation:",e),e}finally{o=t}}dispose(){if(this.state!==u.ComputationState.Disposed){this.state=u.ComputationState.Disposed;for(const t of this.sources)t&&typeof t=="object"&&"removeObserver"in t&&t.removeObserver(this);this.sources.clear();for(const t of this.observers)t.sources.delete(this);this.observers.clear(),this.owner&&!this.owner.disposed&&this.owner.sources.delete(this)}}}function w(r){const t=new v(n),e=n;n=t;try{return r(()=>t.dispose())}finally{n=e}}function g(r,t){const e=n;n=r;try{return t()}finally{n=e}}function b(){return n}let c=null;function O(r){c=r}function y(r){if(i)return r();const t=i;i=!0;try{const e=r();return!t&&c&&c(),e}finally{i=t}}function S(r){const t=o;o=null;try{return r()}finally{o=t}}function D(r,t){const e=new l(r,t||n);return e.execute(),e}function B(){return{computation:o,batch:i}}const _={getCurrentComputation:()=>o,getCurrentOwner:()=>n,getComputationCount:()=>a,getOwnerCount:()=>h,isBatching:()=>i};exports.ComputationImpl=l;exports.DEBUG=_;exports.batch=y;exports.createComputation=D;exports.createRoot=w;exports.getCurrentComputation=d;exports.getCurrentOwner=m;exports.getOwner=b;exports.getReactiveContext=B;exports.isBatchingUpdates=C;exports.runWithOwner=g;exports.setFlushFunction=O;exports.untrack=S;
-//# sourceMappingURL=context.cjs.map

package/dist/reactive/context.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.cjs","sources":["../../src/reactive/context.ts"],"sourcesContent":["/**\n * Reactive context and computation management\n *\n * Manages the reactive execution context, dependency tracking,\n * and computation lifecycle.\n */\n\nimport type { CleanupFunction, Computation, Owner, ReactiveContext } from './types'\nimport { ComputationState } from './types'\n\nlet computationIdCounter = 0\nlet ownerIdCounter = 0\n\n/**\n * Global reactive context\n */\nlet currentComputation: Computation | null = null\nlet currentOwner: Owner | null = null\nlet isBatching = false\n\n/**\n * Get the current computation context\n */\nexport function getCurrentComputation(): Computation | null {\n  return currentComputation\n}\n\n/**\n * Get the current owner context\n */\nexport function getCurrentOwner(): Owner | null {\n  return currentOwner\n}\n\n/**\n * Check if we're currently batching updates\n */\nexport function isBatchingUpdates(): boolean {\n  return isBatching\n}\n\n/**\n * Owner implementation for managing cleanup and context\n */\nclass OwnerImpl implements Owner {\n  readonly id: number\n  readonly parent: Owner | null\n  readonly context = new Map<symbol, any>()\n  readonly cleanups: CleanupFunction[] = []\n  readonly sources = new Set<Computation>()\n  disposed = false\n\n  constructor(parent: Owner | null = null) {\n    this.id = ++ownerIdCounter\n    this.parent = parent\n  }\n\n  dispose(): void {\n    if (this.disposed) return\n\n    this.disposed = true\n\n    // Dispose all child computations\n    for (const computation of this.sources) {\n      computation.dispose()\n    }\n    this.sources.clear()\n\n    // Run cleanup functions\n    for (const cleanup of this.cleanups) {\n      try {\n        cleanup()\n      } catch (error) {\n        console.error('Error in cleanup function:', error)\n      }\n    }\n    this.cleanups.length = 0\n\n    // Remove from parent\n    if (this.parent && !this.parent.disposed) {\n      this.parent.sources.delete(this as any)\n    }\n  }\n}\n\n/**\n * Computation implementation\n */\nexport class ComputationImpl implements Computation {\n  readonly id: number\n  readonly owner: Owner | null\n  readonly fn: () => any\n  readonly sources = new Set<any>() // Signals this computation depends on\n  readonly observers = new Set<Computation>() // Computations that depend on this\n  state = ComputationState.Dirty\n  value: any = undefined\n\n  constructor(fn: () => any, owner: Owner | null = null) {\n    this.id = ++computationIdCounter\n    this.fn = fn\n    this.owner = owner\n\n    if (owner && !owner.disposed) {\n      owner.sources.add(this)\n    }\n  }\n\n  execute(): any {\n    if (this.state === ComputationState.Disposed) {\n      return this.value\n    }\n\n    // Clean up old dependencies\n    for (const source of this.sources) {\n      if (source && typeof source === 'object' && 'removeObserver' in source) {\n        ;(source as any).removeObserver(this)\n      }\n    }\n    this.sources.clear()\n\n    const prevComputation = currentComputation\n    currentComputation = this\n\n    try {\n      this.state = ComputationState.Clean\n      this.value = this.fn()\n      return this.value\n    } catch (error) {\n      this.state = ComputationState.Disposed\n      // Don't suppress errors - let them propagate for proper error handling\n      // Only log in non-test environments to avoid polluting test output\n      if (typeof process === 'undefined' || process.env.NODE_ENV !== 'test') {\n        console.error('Error in computation:', error)\n      }\n      throw error\n    } finally {\n      currentComputation = prevComputation\n    }\n  }\n\n  dispose(): void {\n    if (this.state === ComputationState.Disposed) return\n\n    this.state = ComputationState.Disposed\n\n    // Remove from all sources\n    for (const source of this.sources) {\n      if (source && typeof source === 'object' && 'removeObserver' in source) {\n        ;(source as any).removeObserver(this)\n      }\n    }\n    this.sources.clear()\n\n    // Notify observers that this computation is disposed\n    for (const observer of this.observers) {\n      observer.sources.delete(this)\n    }\n    this.observers.clear()\n\n    // Remove from owner\n    if (this.owner && !this.owner.disposed) {\n      this.owner.sources.delete(this)\n    }\n  }\n}\n\n/**\n * Create a new reactive computation root\n */\nexport function createRoot<T>(fn: (dispose: () => void) => T): T {\n  const owner = new OwnerImpl(currentOwner)\n  const prevOwner = currentOwner\n  currentOwner = owner\n\n  try {\n    return fn(() => owner.dispose())\n  } finally {\n    currentOwner = prevOwner\n  }\n}\n\n/**\n * Run a function with a specific owner context\n */\nexport function runWithOwner<T>(owner: Owner | null, fn: () => T): T {\n  const prevOwner = currentOwner\n  currentOwner = owner\n\n  try {\n    return fn()\n  } finally {\n    currentOwner = prevOwner\n  }\n}\n\n/**\n * Get the current owner context\n */\nexport function getOwner(): Owner | null {\n  return currentOwner\n}\n\n// Global flush function reference\nlet flushFunction: (() => void) | null = null\n\n/**\n * Set the flush function (called by signal module)\n */\nexport function setFlushFunction(fn: () => void): void {\n  flushFunction = fn\n}\n\n/**\n * Batch multiple updates together\n */\nexport function batch<T>(fn: () => T): T {\n  if (isBatching) {\n    return fn()\n  }\n\n  const wasBatching = isBatching\n  isBatching = true\n\n  try {\n    const result = fn()\n    // Flush updates after batch completes\n    if (!wasBatching && flushFunction) {\n      flushFunction()\n    }\n    return result\n  } finally {\n    isBatching = wasBatching\n  }\n}\n\n/**\n * Read a signal without tracking dependency\n */\nexport function untrack<T>(fn: () => T): T {\n  const prevComputation = currentComputation\n  currentComputation = null\n\n  try {\n    return fn()\n  } finally {\n    currentComputation = prevComputation\n  }\n}\n\n/**\n * Add cleanup function to current owner\n */\nexport function onCleanup(fn: CleanupFunction): void {\n  if (currentOwner && !currentOwner.disposed) {\n    currentOwner.cleanups.push(fn)\n  }\n}\n\n/**\n * Create a computation that runs immediately and tracks dependencies\n */\nexport function createComputation<T>(fn: () => T, owner?: Owner): ComputationImpl {\n  const computation = new ComputationImpl(fn, owner || currentOwner)\n  computation.execute()\n  return computation\n}\n\n/**\n * Get reactive context information\n */\nexport function getReactiveContext(): ReactiveContext {\n  return {\n    computation: currentComputation,\n    batch: isBatching,\n  }\n}\n\n/**\n * Debug utilities\n */\nexport const DEBUG = {\n  getCurrentComputation: () => currentComputation,\n  getCurrentOwner: () => currentOwner,\n  getComputationCount: () => computationIdCounter,\n  getOwnerCount: () => ownerIdCounter,\n  isBatching: () => isBatching,\n}\n"],"names":["computationIdCounter","ownerIdCounter","currentComputation","currentOwner","isBatching","getCurrentComputation","getCurrentOwner","isBatchingUpdates","OwnerImpl","parent","__publicField","computation","cleanup","error","ComputationImpl","fn","owner","ComputationState","source","prevComputation","observer","createRoot","prevOwner","runWithOwner","getOwner","flushFunction","setFlushFunction","batch","wasBatching","result","untrack","createComputation","getReactiveContext","DEBUG"],"mappings":"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"}

package/dist/reactive/context.js

@@ -1,143 +0,0 @@
-import { ComputationState as u } from "./types.js";
-var l = Object.defineProperty, p = (r, t, e) => t in r ? l(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, s = (r, t, e) => p(r, typeof t != "symbol" ? t + "" : t, e);
-let a = 0, h = 0, o = null, n = null, i = !1;
-function v() {
-  return o;
-}
-function w() {
-  return n;
-}
-function C() {
-  return i;
-}
-class f {
-  constructor(t = null) {
-    s(this, "id"), s(this, "parent"), s(this, "context", /* @__PURE__ */ new Map()), s(this, "cleanups", []), s(this, "sources", /* @__PURE__ */ new Set()), s(this, "disposed", !1), this.id = ++h, this.parent = t;
-  }
-  dispose() {
-    if (!this.disposed) {
-      this.disposed = !0;
-      for (const t of this.sources)
-        t.dispose();
-      this.sources.clear();
-      for (const t of this.cleanups)
-        try {
-          t();
-        } catch (e) {
-          console.error("Error in cleanup function:", e);
-        }
-      this.cleanups.length = 0, this.parent && !this.parent.disposed && this.parent.sources.delete(this);
-    }
-  }
-}
-class d {
-  constructor(t, e = null) {
-    s(this, "id"), s(this, "owner"), s(this, "fn"), s(this, "sources", /* @__PURE__ */ new Set()), s(this, "observers", /* @__PURE__ */ new Set()), s(this, "state", u.Dirty), s(this, "value"), this.id = ++a, this.fn = t, this.owner = e, e && !e.disposed && e.sources.add(this);
-  }
-  execute() {
-    if (this.state === u.Disposed)
-      return this.value;
-    for (const e of this.sources)
-      e && typeof e == "object" && "removeObserver" in e && e.removeObserver(this);
-    this.sources.clear();
-    const t = o;
-    o = this;
-    try {
-      return this.state = u.Clean, this.value = this.fn(), this.value;
-    } catch (e) {
-      throw this.state = u.Disposed, (typeof process > "u" || process.env.NODE_ENV !== "test") && console.error("Error in computation:", e), e;
-    } finally {
-      o = t;
-    }
-  }
-  dispose() {
-    if (this.state !== u.Disposed) {
-      this.state = u.Disposed;
-      for (const t of this.sources)
-        t && typeof t == "object" && "removeObserver" in t && t.removeObserver(this);
-      this.sources.clear();
-      for (const t of this.observers)
-        t.sources.delete(this);
-      this.observers.clear(), this.owner && !this.owner.disposed && this.owner.sources.delete(this);
-    }
-  }
-}
-function b(r) {
-  const t = new f(n), e = n;
-  n = t;
-  try {
-    return r(() => t.dispose());
-  } finally {
-    n = e;
-  }
-}
-function O(r, t) {
-  const e = n;
-  n = r;
-  try {
-    return t();
-  } finally {
-    n = e;
-  }
-}
-function g() {
-  return n;
-}
-let c = null;
-function y(r) {
-  c = r;
-}
-function D(r) {
-  if (i)
-    return r();
-  const t = i;
-  i = !0;
-  try {
-    const e = r();
-    return !t && c && c(), e;
-  } finally {
-    i = t;
-  }
-}
-function _(r) {
-  const t = o;
-  o = null;
-  try {
-    return r();
-  } finally {
-    o = t;
-  }
-}
-function x(r, t) {
-  const e = new d(r, t || n);
-  return e.execute(), e;
-}
-function B() {
-  return {
-    computation: o,
-    batch: i
-  };
-}
-const E = {
-  getCurrentComputation: () => o,
-  getCurrentOwner: () => n,
-  getComputationCount: () => a,
-  getOwnerCount: () => h,
-  isBatching: () => i
-};
-export {
-  d as ComputationImpl,
-  E as DEBUG,
-  D as batch,
-  x as createComputation,
-  b as createRoot,
-  v as getCurrentComputation,
-  w as getCurrentOwner,
-  g as getOwner,
-  B as getReactiveContext,
-  C as isBatchingUpdates,
-  O as runWithOwner,
-  y as setFlushFunction,
-  _ as untrack
-};
-//# sourceMappingURL=context.js.map

package/dist/reactive/context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.js","sources":["../../src/reactive/context.ts"],"sourcesContent":["/**\n * Reactive context and computation management\n *\n * Manages the reactive execution context, dependency tracking,\n * and computation lifecycle.\n */\n\nimport type { CleanupFunction, Computation, Owner, ReactiveContext } from './types'\nimport { ComputationState } from './types'\n\nlet computationIdCounter = 0\nlet ownerIdCounter = 0\n\n/**\n * Global reactive context\n */\nlet currentComputation: Computation | null = null\nlet currentOwner: Owner | null = null\nlet isBatching = false\n\n/**\n * Get the current computation context\n */\nexport function getCurrentComputation(): Computation | null {\n  return currentComputation\n}\n\n/**\n * Get the current owner context\n */\nexport function getCurrentOwner(): Owner | null {\n  return currentOwner\n}\n\n/**\n * Check if we're currently batching updates\n */\nexport function isBatchingUpdates(): boolean {\n  return isBatching\n}\n\n/**\n * Owner implementation for managing cleanup and context\n */\nclass OwnerImpl implements Owner {\n  readonly id: number\n  readonly parent: Owner | null\n  readonly context = new Map<symbol, any>()\n  readonly cleanups: CleanupFunction[] = []\n  readonly sources = new Set<Computation>()\n  disposed = false\n\n  constructor(parent: Owner | null = null) {\n    this.id = ++ownerIdCounter\n    this.parent = parent\n  }\n\n  dispose(): void {\n    if (this.disposed) return\n\n    this.disposed = true\n\n    // Dispose all child computations\n    for (const computation of this.sources) {\n      computation.dispose()\n    }\n    this.sources.clear()\n\n    // Run cleanup functions\n    for (const cleanup of this.cleanups) {\n      try {\n        cleanup()\n      } catch (error) {\n        console.error('Error in cleanup function:', error)\n      }\n    }\n    this.cleanups.length = 0\n\n    // Remove from parent\n    if (this.parent && !this.parent.disposed) {\n      this.parent.sources.delete(this as any)\n    }\n  }\n}\n\n/**\n * Computation implementation\n */\nexport class ComputationImpl implements Computation {\n  readonly id: number\n  readonly owner: Owner | null\n  readonly fn: () => any\n  readonly sources = new Set<any>() // Signals this computation depends on\n  readonly observers = new Set<Computation>() // Computations that depend on this\n  state = ComputationState.Dirty\n  value: any = undefined\n\n  constructor(fn: () => any, owner: Owner | null = null) {\n    this.id = ++computationIdCounter\n    this.fn = fn\n    this.owner = owner\n\n    if (owner && !owner.disposed) {\n      owner.sources.add(this)\n    }\n  }\n\n  execute(): any {\n    if (this.state === ComputationState.Disposed) {\n      return this.value\n    }\n\n    // Clean up old dependencies\n    for (const source of this.sources) {\n      if (source && typeof source === 'object' && 'removeObserver' in source) {\n        ;(source as any).removeObserver(this)\n      }\n    }\n    this.sources.clear()\n\n    const prevComputation = currentComputation\n    currentComputation = this\n\n    try {\n      this.state = ComputationState.Clean\n      this.value = this.fn()\n      return this.value\n    } catch (error) {\n      this.state = ComputationState.Disposed\n      // Don't suppress errors - let them propagate for proper error handling\n      // Only log in non-test environments to avoid polluting test output\n      if (typeof process === 'undefined' || process.env.NODE_ENV !== 'test') {\n        console.error('Error in computation:', error)\n      }\n      throw error\n    } finally {\n      currentComputation = prevComputation\n    }\n  }\n\n  dispose(): void {\n    if (this.state === ComputationState.Disposed) return\n\n    this.state = ComputationState.Disposed\n\n    // Remove from all sources\n    for (const source of this.sources) {\n      if (source && typeof source === 'object' && 'removeObserver' in source) {\n        ;(source as any).removeObserver(this)\n      }\n    }\n    this.sources.clear()\n\n    // Notify observers that this computation is disposed\n    for (const observer of this.observers) {\n      observer.sources.delete(this)\n    }\n    this.observers.clear()\n\n    // Remove from owner\n    if (this.owner && !this.owner.disposed) {\n      this.owner.sources.delete(this)\n    }\n  }\n}\n\n/**\n * Create a new reactive computation root\n */\nexport function createRoot<T>(fn: (dispose: () => void) => T): T {\n  const owner = new OwnerImpl(currentOwner)\n  const prevOwner = currentOwner\n  currentOwner = owner\n\n  try {\n    return fn(() => owner.dispose())\n  } finally {\n    currentOwner = prevOwner\n  }\n}\n\n/**\n * Run a function with a specific owner context\n */\nexport function runWithOwner<T>(owner: Owner | null, fn: () => T): T {\n  const prevOwner = currentOwner\n  currentOwner = owner\n\n  try {\n    return fn()\n  } finally {\n    currentOwner = prevOwner\n  }\n}\n\n/**\n * Get the current owner context\n */\nexport function getOwner(): Owner | null {\n  return currentOwner\n}\n\n// Global flush function reference\nlet flushFunction: (() => void) | null = null\n\n/**\n * Set the flush function (called by signal module)\n */\nexport function setFlushFunction(fn: () => void): void {\n  flushFunction = fn\n}\n\n/**\n * Batch multiple updates together\n */\nexport function batch<T>(fn: () => T): T {\n  if (isBatching) {\n    return fn()\n  }\n\n  const wasBatching = isBatching\n  isBatching = true\n\n  try {\n    const result = fn()\n    // Flush updates after batch completes\n    if (!wasBatching && flushFunction) {\n      flushFunction()\n    }\n    return result\n  } finally {\n    isBatching = wasBatching\n  }\n}\n\n/**\n * Read a signal without tracking dependency\n */\nexport function untrack<T>(fn: () => T): T {\n  const prevComputation = currentComputation\n  currentComputation = null\n\n  try {\n    return fn()\n  } finally {\n    currentComputation = prevComputation\n  }\n}\n\n/**\n * Add cleanup function to current owner\n */\nexport function onCleanup(fn: CleanupFunction): void {\n  if (currentOwner && !currentOwner.disposed) {\n    currentOwner.cleanups.push(fn)\n  }\n}\n\n/**\n * Create a computation that runs immediately and tracks dependencies\n */\nexport function createComputation<T>(fn: () => T, owner?: Owner): ComputationImpl {\n  const computation = new ComputationImpl(fn, owner || currentOwner)\n  computation.execute()\n  return computation\n}\n\n/**\n * Get reactive context information\n */\nexport function getReactiveContext(): ReactiveContext {\n  return {\n    computation: currentComputation,\n    batch: isBatching,\n  }\n}\n\n/**\n * Debug utilities\n */\nexport const DEBUG = {\n  getCurrentComputation: () => currentComputation,\n  getCurrentOwner: () => currentOwner,\n  getComputationCount: () => computationIdCounter,\n  getOwnerCount: () => ownerIdCounter,\n  isBatching: () => isBatching,\n}\n"],"names":["computationIdCounter","ownerIdCounter","currentComputation","currentOwner","isBatching","getCurrentComputation","getCurrentOwner","isBatchingUpdates","OwnerImpl","parent","__publicField","computation","cleanup","error","ComputationImpl","fn","owner","ComputationState","source","prevComputation","observer","createRoot","prevOwner","runWithOwner","getOwner","flushFunction","setFlushFunction","batch","wasBatching","result","untrack","createComputation","getReactiveContext","DEBUG"],"mappings":"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"}

package/dist/reactive/effect.cjs

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./context.cjs");function a(e,t={}){const u=s.getCurrentOwner();let r,n=!0;const o=()=>{const f=e(r);return n&&(n=!1),r=f,f},c=new s.ComputationImpl(o,u);return t.name&&Object.defineProperty(c,"name",{value:t.name,enumerable:!1}),c.execute(),c}function l(e,t={}){const u=s.getCurrentOwner();let r,n=!1;const o=()=>{if(!n)return n=!0,e(r);const f=e(r);return r=f,f},c=new s.ComputationImpl(o,u);return t.name&&Object.defineProperty(c,"name",{value:t.name,enumerable:!1}),c.execute(),c}function m(e,t={}){const u=s.getCurrentOwner(),r=()=>{const o=e(void 0);return n.dispose(),o},n=new s.ComputationImpl(r,u);return t.name&&Object.defineProperty(n,"name",{value:`${t.name}(once)`,enumerable:!1}),n.execute(),n}function d(e,t={}){return a(e,{...t,name:`${t.name||"sync"}(sync)`})}function p(e){e.dispose()}function i(e){return e.state===3}function E(e){return{id:e.id,name:e.name||"anonymous",state:e.state,sourceCount:e.sources.size,observerCount:e.observers.size,disposed:i(e),type:"Effect"}}exports.createEffect=a;exports.createOnceEffect=m;exports.createRenderEffect=l;exports.createSyncEffect=d;exports.disposeEffect=p;exports.getEffectInfo=E;exports.isEffectDisposed=i;
-//# sourceMappingURL=effect.cjs.map

package/dist/reactive/effect.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"effect.cjs","sources":["../../src/reactive/effect.ts"],"sourcesContent":["/**\n * Effect implementation for side effects in reactive system\n *\n * Effects run when their dependencies change, enabling reactive\n * side effects like DOM updates, logging, API calls, etc.\n */\n\nimport { ComputationImpl, getCurrentOwner } from './context'\nimport type { EffectFunction, EffectOptions } from './types'\n\n/**\n * Effect function type\n */\nexport type Effect = ComputationImpl\n\n/**\n * Create a reactive effect that runs when dependencies change\n *\n * @param fn The effect function to run\n * @param options Effect configuration options\n * @returns The effect computation\n *\n * @example\n * ```typescript\n * const [count, setCount] = createSignal(0)\n *\n * createEffect(() => {\n *   console.log('Count changed:', count())\n * })\n *\n * setCount(5) // Logs: \"Count changed: 5\"\n * ```\n */\nexport function createEffect<T>(fn: EffectFunction<T>, options: EffectOptions = {}): Effect {\n  const owner = getCurrentOwner()\n\n  let previousValue: T | undefined\n  let isFirst = true\n\n  const effectFn = () => {\n    const nextValue = fn(previousValue)\n\n    if (!isFirst) {\n      previousValue = nextValue\n    } else {\n      isFirst = false\n      previousValue = nextValue\n    }\n\n    return nextValue\n  }\n\n  // Create the computation\n  const effect = new ComputationImpl(effectFn, owner)\n\n  // Add debug name if provided\n  if (options.name) {\n    Object.defineProperty(effect, 'name', {\n      value: options.name,\n      enumerable: false,\n    })\n  }\n\n  // Execute immediately to establish dependencies\n  effect.execute()\n\n  return effect\n}\n\n/**\n * Create an effect that only runs after dependencies change (not on first run)\n *\n * @param fn The effect function to run\n * @param options Effect configuration options\n * @returns The effect computation\n *\n * @example\n * ```typescript\n * const [count, setCount] = createSignal(0)\n *\n * createRenderEffect(() => {\n *   // This won't run immediately, only when count changes\n *   document.title = `Count: ${count()}`\n * })\n * ```\n */\nexport function createRenderEffect<T>(fn: EffectFunction<T>, options: EffectOptions = {}): Effect {\n  const owner = getCurrentOwner()\n\n  let previousValue: T | undefined\n  let hasRun = false\n\n  const effectFn = () => {\n    if (!hasRun) {\n      hasRun = true\n      // Track dependencies but don't run the effect\n      return fn(previousValue)\n    }\n\n    const nextValue = fn(previousValue)\n    previousValue = nextValue\n    return nextValue\n  }\n\n  const effect = new ComputationImpl(effectFn, owner)\n\n  if (options.name) {\n    Object.defineProperty(effect, 'name', {\n      value: options.name,\n      enumerable: false,\n    })\n  }\n\n  // Execute to establish dependencies but not run the actual effect\n  effect.execute()\n\n  return effect\n}\n\n/**\n * Create a one-time effect that disposes itself after first execution\n *\n * @param fn The effect function to run once\n * @param options Effect configuration options\n * @returns The effect computation\n */\nexport function createOnceEffect<T>(fn: EffectFunction<T>, options: EffectOptions = {}): Effect {\n  const owner = getCurrentOwner()\n\n  const effectFn = () => {\n    const result = fn(undefined)\n    // Dispose the effect after first run\n    effect.dispose()\n    return result\n  }\n\n  const effect = new ComputationImpl(effectFn, owner)\n\n  if (options.name) {\n    Object.defineProperty(effect, 'name', {\n      value: `${options.name}(once)`,\n      enumerable: false,\n    })\n  }\n\n  effect.execute()\n\n  return effect\n}\n\n/**\n * Create an effect that runs synchronously (not batched)\n *\n * @param fn The effect function to run\n * @param options Effect configuration options\n * @returns The effect computation\n */\nexport function createSyncEffect<T>(fn: EffectFunction<T>, options: EffectOptions = {}): Effect {\n  // TODO: Implement synchronous execution\n  // For now, use regular effect\n  return createEffect(fn, { ...options, name: `${options.name || 'sync'}(sync)` })\n}\n\n/**\n * Dispose an effect\n */\nexport function disposeEffect(effect: Effect): void {\n  effect.dispose()\n}\n\n/**\n * Check if an effect is disposed\n */\nexport function isEffectDisposed(effect: Effect): boolean {\n  return effect.state === 3 // ComputationState.Disposed\n}\n\n/**\n * Get effect debug information\n */\nexport function getEffectInfo(effect: Effect): object {\n  return {\n    id: effect.id,\n    name: (effect as any).name || 'anonymous',\n    state: effect.state,\n    sourceCount: effect.sources.size,\n    observerCount: effect.observers.size,\n    disposed: isEffectDisposed(effect),\n    type: 'Effect',\n  }\n}\n\n// Re-export types\nexport type { EffectFunction, EffectOptions }\n"],"names":["createEffect","fn","options","owner","getCurrentOwner","previousValue","isFirst","effectFn","nextValue","effect","ComputationImpl","createRenderEffect","hasRun","createOnceEffect","result","createSyncEffect","disposeEffect","isEffectDisposed","getEffectInfo"],"mappings":"iHAiCO,SAASA,EAAgBC,EAAuBC,EAAyB,GAAY,CAC1F,MAAMC,EAAQC,EAAAA,gBAAA,EAEd,IAAIC,EACAC,EAAU,GAEd,MAAMC,EAAW,IAAM,CACrB,MAAMC,EAAYP,EAAGI,CAAa,EAElC,OAAKC,IAGHA,EAAU,IACVD,EAAgBG,EAGXA,CACT,EAGMC,EAAS,IAAIC,kBAAgBH,EAAUJ,CAAK,EAGlD,OAAID,EAAQ,MACV,OAAO,eAAeO,EAAQ,OAAQ,CACpC,MAAOP,EAAQ,KACf,WAAY,EAAA,CACb,EAIHO,EAAO,QAAA,EAEAA,CACT,CAmBO,SAASE,EAAsBV,EAAuBC,EAAyB,GAAY,CAChG,MAAMC,EAAQC,EAAAA,gBAAA,EAEd,IAAIC,EACAO,EAAS,GAEb,MAAML,EAAW,IAAM,CACrB,GAAI,CAACK,EACH,OAAAA,EAAS,GAEFX,EAAGI,CAAa,EAGzB,MAAMG,EAAYP,EAAGI,CAAa,EAClC,OAAAA,EAAgBG,EACTA,CACT,EAEMC,EAAS,IAAIC,kBAAgBH,EAAUJ,CAAK,EAElD,OAAID,EAAQ,MACV,OAAO,eAAeO,EAAQ,OAAQ,CACpC,MAAOP,EAAQ,KACf,WAAY,EAAA,CACb,EAIHO,EAAO,QAAA,EAEAA,CACT,CASO,SAASI,EAAoBZ,EAAuBC,EAAyB,GAAY,CAC9F,MAAMC,EAAQC,EAAAA,gBAAA,EAERG,EAAW,IAAM,CACrB,MAAMO,EAASb,EAAG,MAAS,EAE3B,OAAAQ,EAAO,QAAA,EACAK,CACT,EAEML,EAAS,IAAIC,kBAAgBH,EAAUJ,CAAK,EAElD,OAAID,EAAQ,MACV,OAAO,eAAeO,EAAQ,OAAQ,CACpC,MAAO,GAAGP,EAAQ,IAAI,SACtB,WAAY,EAAA,CACb,EAGHO,EAAO,QAAA,EAEAA,CACT,CASO,SAASM,EAAoBd,EAAuBC,EAAyB,GAAY,CAG9F,OAAOF,EAAaC,EAAI,CAAE,GAAGC,EAAS,KAAM,GAAGA,EAAQ,MAAQ,MAAM,QAAA,CAAU,CACjF,CAKO,SAASc,EAAcP,EAAsB,CAClDA,EAAO,QAAA,CACT,CAKO,SAASQ,EAAiBR,EAAyB,CACxD,OAAOA,EAAO,QAAU,CAC1B,CAKO,SAASS,EAAcT,EAAwB,CACpD,MAAO,CACL,GAAIA,EAAO,GACX,KAAOA,EAAe,MAAQ,YAC9B,MAAOA,EAAO,MACd,YAAaA,EAAO,QAAQ,KAC5B,cAAeA,EAAO,UAAU,KAChC,SAAUQ,EAAiBR,CAAM,EACjC,KAAM,QAAA,CAEV"}