@vorra/core 0.3.0

package/dist/di.js

@@ -0,0 +1,261 @@
+//#region src/di.ts
+const INJECTABLE_META = /* @__PURE__ */ new WeakMap();
+/**
+* Marks a class as injectable and configures where it is provided.
+*
+* @example
+* \@Injectable({ providedIn: 'root' })
+* class UserService {
+*   readonly users = signal<User[]>([]);
+* }
+*/
+function Injectable(options = {}) {
+	return (target) => {
+		const ctor = target;
+		const existing = INJECTABLE_META.get(ctor);
+		INJECTABLE_META.set(ctor, {
+			providedIn: options.providedIn ?? "root",
+			deps: existing?.deps ?? []
+		});
+	};
+}
+/**
+* Declares the constructor dependencies for a class, enabling DI without
+* TypeScript decorator metadata (emitDecoratorMetadata).
+*
+* @example
+* \@Injectable({ providedIn: 'root' })
+* \@Inject([HttpClient, AuthService])
+* class UserService {
+*   constructor(private http: HttpClient, private auth: AuthService) {}
+* }
+*/
+function Inject(deps) {
+	return (target) => {
+		const ctor = target;
+		const existing = INJECTABLE_META.get(ctor);
+		if (existing) existing.deps = deps;
+		else INJECTABLE_META.set(ctor, {
+			providedIn: "root",
+			deps
+		});
+	};
+}
+let tokenIdCounter = 0;
+/**
+* A typed token used to inject values that aren't class instances — configs,
+* primitives, interfaces, or abstract types.
+*
+* @example
+* const API_URL = new InjectionToken<string>('API_URL', {
+*   providedIn: 'root',
+*   factory: () => 'https://api.example.com',
+* });
+*
+* // Later:
+* const url = inject(API_URL); // → 'https://api.example.com'
+*/
+var InjectionToken = class {
+	constructor(description, options) {
+		this.id = ++tokenIdCounter;
+		this.description = description;
+		this.options = options;
+	}
+	toString() {
+		return `InjectionToken(${this.description})`;
+	}
+};
+const NOT_FOUND = Symbol("NOT_FOUND");
+/**
+* A hierarchical container that resolves and caches provider instances.
+* Child injectors delegate to their parent when a token isn't found locally.
+*/
+var Injector = class Injector {
+	constructor(providers = [], parent = null) {
+		this.parent = parent;
+		this.instances = /* @__PURE__ */ new Map();
+		this.resolving = /* @__PURE__ */ new Set();
+		this.providers = /* @__PURE__ */ new Map();
+		for (const p of providers) this.providers.set(p.provide, p);
+	}
+	get(token, optional = false) {
+		const result = this.resolve(token);
+		if (result === NOT_FOUND) {
+			if (optional) return null;
+			throw new Error(`[Vorra DI] No provider found for ${tokenName(token)}. Did you forget @Injectable() or to add it to your providers array?`);
+		}
+		return result;
+	}
+	resolve(token) {
+		if (this.instances.has(token)) return this.instances.get(token);
+		if (this.resolving.has(token)) throw new Error(`[Vorra DI] Circular dependency detected while resolving ${tokenName(token)}.`);
+		const provider = this.providers.get(token);
+		if (provider) {
+			this.resolving.add(token);
+			try {
+				const instance = this.instantiate(provider);
+				this.instances.set(token, instance);
+				return instance;
+			} finally {
+				this.resolving.delete(token);
+			}
+		}
+		if (token instanceof InjectionToken && token.options?.factory) {
+			const instance = runInContext(this, token.options.factory);
+			this.instances.set(token, instance);
+			return instance;
+		}
+		if (typeof token === "function") {
+			const meta = INJECTABLE_META.get(token);
+			if (meta) {
+				const targetInjector = this.resolveProvidedIn(meta.providedIn);
+				if (targetInjector === this) {
+					this.resolving.add(token);
+					try {
+						const instance = this.instantiateClass(token, meta.deps);
+						this.instances.set(token, instance);
+						return instance;
+					} finally {
+						this.resolving.delete(token);
+					}
+				} else if (targetInjector) return targetInjector.resolve(token);
+			}
+		}
+		if (this.parent) return this.parent.resolve(token);
+		return NOT_FOUND;
+	}
+	instantiate(provider) {
+		if ("useValue" in provider) return provider.useValue;
+		if ("useExisting" in provider) return this.get(provider.useExisting);
+		if ("useFactory" in provider) {
+			const deps = (provider.deps ?? []).map((dep) => this.get(dep));
+			return provider.useFactory(...deps);
+		}
+		const deps = (provider.deps ?? []).map((dep) => this.get(dep));
+		return new provider.useClass(...deps);
+	}
+	instantiateClass(ctor, deps) {
+		return new ctor(...deps.map((dep) => this.get(dep)));
+	}
+	resolveProvidedIn(providedIn) {
+		if (providedIn === "root") return getRootInjector();
+		if (providedIn === "component") return this;
+		if (providedIn instanceof Injector) return providedIn;
+		return null;
+	}
+	/**
+	* Creates a child injector that inherits from this one.
+	* Child providers shadow parent providers for the same token.
+	*/
+	createChild(providers = []) {
+		return new Injector(providers, this);
+	}
+	/**
+	* Destroys this injector — calls onDestroy() on any instances that
+	* implement it, then clears all cached instances.
+	*/
+	destroy() {
+		for (const instance of this.instances.values()) if (instance !== null && typeof instance === "object" && typeof instance.onDestroy === "function") instance.onDestroy();
+		this.instances.clear();
+		this.providers.clear();
+	}
+};
+let _rootInjector = null;
+function getRootInjector() {
+	if (!_rootInjector) _rootInjector = new Injector();
+	return _rootInjector;
+}
+/**
+* Bootstraps the application by creating the root injector with the given
+* providers. Should be called once at app startup.
+*
+* @example
+* bootstrapApp([
+*   { provide: API_URL, useValue: 'https://api.example.com' },
+* ]);
+*/
+function bootstrapApp(providers = []) {
+	_rootInjector = new Injector(providers);
+	return _rootInjector;
+}
+/** Resets the root injector — primarily useful in tests. */
+function resetRootInjector() {
+	_rootInjector?.destroy();
+	_rootInjector = null;
+}
+/**
+* The active injector context for inject() calls.
+* Set during component/service instantiation.
+*/
+let activeInjector = null;
+/**
+* Runs a function within a specific injector context, making inject() calls
+* inside resolve against that injector.
+*/
+function runInContext(injector, fn) {
+	const prev = activeInjector;
+	activeInjector = injector;
+	try {
+		return fn();
+	} finally {
+		activeInjector = prev;
+	}
+}
+/**
+* Returns the currently active injector, or null if called outside an
+* injection context.
+*/
+function getActiveInjector() {
+	return activeInjector;
+}
+function inject(token, options = {}) {
+	if (!activeInjector) throw new Error("[Vorra DI] inject() called outside of an injection context. inject() can only be used during component or service construction.");
+	return activeInjector.get(token, options.optional);
+}
+function tokenName(token) {
+	if (token instanceof InjectionToken) return token.toString();
+	if (typeof token === "function") return token.name || "(anonymous class)";
+	return String(token);
+}
+/**
+* Registers a cleanup callback to run when the injector that owns this
+* service instance is destroyed.
+*
+* Call this inside a service constructor (within an injection context).
+*
+* @example
+* \@Injectable({ providedIn: 'root' })
+* class WebSocketService {
+*   #ws: WebSocket;
+*   constructor() {
+*     this.#ws = new WebSocket('wss://...');
+*     onDestroy(() => this.#ws.close());
+*   }
+* }
+*/
+function onDestroy(fn) {
+	if (!activeInjector) throw new Error("[Vorra DI] onDestroy() must be called within an injection context.");
+	new InjectionToken(`__destroyRef__`);
+	getOrCreateDestroyRef(activeInjector).callbacks.push(fn);
+}
+const destroyRefs = /* @__PURE__ */ new WeakMap();
+function getOrCreateDestroyRef(injector) {
+	if (!destroyRefs.has(injector)) destroyRefs.set(injector, { callbacks: [] });
+	return destroyRefs.get(injector);
+}
+/**
+* Runs all onDestroy callbacks registered against an injector.
+* Called automatically by Injector.destroy(), but also exported for
+* use in the component runtime.
+*/
+function runDestroyCallbacks(injector) {
+	const ref = destroyRefs.get(injector);
+	if (ref) {
+		for (const cb of ref.callbacks) cb();
+		ref.callbacks = [];
+	}
+}
+//#endregion
+export { Inject, Injectable, InjectionToken, Injector, bootstrapApp, getActiveInjector, getRootInjector, inject, onDestroy, resetRootInjector, runDestroyCallbacks, runInContext };
+
+//# sourceMappingURL=di.js.map

package/dist/di.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"di.js","names":[],"sources":["../src/di.ts"],"sourcesContent":["// =============================================================================\r\n// Vorra DI System\r\n// Injectable / InjectionToken / inject() / Injector / runInContext()\r\n// =============================================================================\r\n\r\nimport type { WritableSignal, ReadonlySignal } from './reactivity';\r\n\r\n// ---------------------------------------------------------------------------\r\n// Types\r\n// ---------------------------------------------------------------------------\r\n\r\n/** Where a provider is instantiated in the injector tree. */\r\nexport type ProvidedIn = 'root' | 'component' | Injector;\r\n\r\nexport interface InjectableOptions {\r\n  providedIn?: ProvidedIn;\r\n}\r\n\r\n/** Describes how to provide a value for a given token. */\r\nexport type Provider<T> =\r\n  | ClassProvider<T>\r\n  | ValueProvider<T>\r\n  | FactoryProvider<T>\r\n  | ExistingProvider<T>;\r\n\r\nexport interface ClassProvider<T> {\r\n  provide: Token<T>;\r\n  useClass: new (...args: unknown[]) => T;\r\n  deps?: Token<unknown>[];\r\n}\r\n\r\nexport interface ValueProvider<T> {\r\n  provide: Token<T>;\r\n  useValue: T;\r\n}\r\n\r\nexport interface FactoryProvider<T> {\r\n  provide: Token<T>;\r\n  useFactory: (...args: unknown[]) => T;\r\n  deps?: Token<unknown>[];\r\n}\r\n\r\nexport interface ExistingProvider<T> {\r\n  provide: Token<T>;\r\n  useExisting: Token<T>;\r\n}\r\n\r\n/** Anything that can be used as a DI token. */\r\nexport type Token<T> =\r\n  | (new (...args: unknown[]) => T)\r\n  | InjectionToken<T>\r\n  | AbstractToken<T>;\r\n\r\n/** Marker interface for abstract class tokens. */\r\nexport interface AbstractToken<T> {\r\n  readonly __tokenType: T;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// INJECTABLE_META — metadata store for @Injectable classes\r\n// ---------------------------------------------------------------------------\r\n\r\nconst INJECTABLE_META = new WeakMap<\r\n  new (...args: unknown[]) => unknown,\r\n  { providedIn: ProvidedIn; deps: Token<unknown>[] }\r\n>();\r\n\r\n// ---------------------------------------------------------------------------\r\n// @Injectable decorator\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Marks a class as injectable and configures where it is provided.\r\n *\r\n * @example\r\n * \\@Injectable({ providedIn: 'root' })\r\n * class UserService {\r\n *   readonly users = signal<User[]>([]);\r\n * }\r\n */\r\nexport function Injectable(options: InjectableOptions = {}): ClassDecorator {\r\n  return (target: unknown) => {\r\n    const ctor = target as new (...args: unknown[]) => unknown;\r\n    const existing = INJECTABLE_META.get(ctor);\r\n    INJECTABLE_META.set(ctor, {\r\n      providedIn: options.providedIn ?? 'root',\r\n      deps: existing?.deps ?? [],\r\n    });\r\n  };\r\n}\r\n\r\n/**\r\n * Declares the constructor dependencies for a class, enabling DI without\r\n * TypeScript decorator metadata (emitDecoratorMetadata).\r\n *\r\n * @example\r\n * \\@Injectable({ providedIn: 'root' })\r\n * \\@Inject([HttpClient, AuthService])\r\n * class UserService {\r\n *   constructor(private http: HttpClient, private auth: AuthService) {}\r\n * }\r\n */\r\nexport function Inject(deps: Token<unknown>[]): ClassDecorator {\r\n  return (target: unknown) => {\r\n    const ctor = target as new (...args: unknown[]) => unknown;\r\n    const existing = INJECTABLE_META.get(ctor);\r\n    if (existing) {\r\n      existing.deps = deps;\r\n    } else {\r\n      INJECTABLE_META.set(ctor, { providedIn: 'root', deps });\r\n    }\r\n  };\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// InjectionToken\r\n// ---------------------------------------------------------------------------\r\n\r\nlet tokenIdCounter = 0;\r\n\r\n/**\r\n * A typed token used to inject values that aren't class instances — configs,\r\n * primitives, interfaces, or abstract types.\r\n *\r\n * @example\r\n * const API_URL = new InjectionToken<string>('API_URL', {\r\n *   providedIn: 'root',\r\n *   factory: () => 'https://api.example.com',\r\n * });\r\n *\r\n * // Later:\r\n * const url = inject(API_URL); // → 'https://api.example.com'\r\n */\r\nexport class InjectionToken<T> {\r\n  readonly __tokenType!: T; // phantom type only — never assigned at runtime\r\n  readonly id: number;\r\n  readonly description: string;\r\n  readonly options?: {\r\n    providedIn?: ProvidedIn;\r\n    factory?: () => T;\r\n  };\r\n\r\n  constructor(\r\n    description: string,\r\n    options?: { providedIn?: ProvidedIn; factory?: () => T }\r\n  ) {\r\n    this.id = ++tokenIdCounter;\r\n    this.description = description;\r\n    this.options = options;\r\n  }\r\n\r\n  toString(): string {\r\n    return `InjectionToken(${this.description})`;\r\n  }\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Injector\r\n// ---------------------------------------------------------------------------\r\n\r\nconst NOT_FOUND = Symbol('NOT_FOUND');\r\nconst CIRCULAR = Symbol('CIRCULAR');\r\n\r\n/**\r\n * A hierarchical container that resolves and caches provider instances.\r\n * Child injectors delegate to their parent when a token isn't found locally.\r\n */\r\nexport class Injector {\r\n  private readonly instances = new Map<Token<unknown>, unknown>();\r\n  private readonly resolving = new Set<Token<unknown>>();\r\n  private readonly providers = new Map<Token<unknown>, Provider<unknown>>();\r\n\r\n  constructor(\r\n    providers: Provider<unknown>[] = [],\r\n    private readonly parent: Injector | null = null\r\n  ) {\r\n    for (const p of providers) {\r\n      this.providers.set(p.provide, p);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Resolves a token to its instance. Throws if the token cannot be resolved\r\n   * and `optional` is false (the default).\r\n   */\r\n  get<T>(token: Token<T>, optional?: false): T;\r\n  get<T>(token: Token<T>, optional: true): T | null;\r\n  get<T>(token: Token<T>, optional = false): T | null {\r\n    const result = this.resolve(token);\r\n    if (result === NOT_FOUND) {\r\n      if (optional) return null;\r\n      throw new Error(\r\n        `[Vorra DI] No provider found for ${tokenName(token)}. ` +\r\n        `Did you forget @Injectable() or to add it to your providers array?`\r\n      );\r\n    }\r\n    return result as T;\r\n  }\r\n\r\n  private resolve<T>(token: Token<T>): T | typeof NOT_FOUND {\r\n    // 1. Return cached instance\r\n    if (this.instances.has(token)) {\r\n      return this.instances.get(token) as T;\r\n    }\r\n\r\n    // 2. Circular dependency guard\r\n    if (this.resolving.has(token)) {\r\n      throw new Error(\r\n        `[Vorra DI] Circular dependency detected while resolving ${tokenName(token)}.`\r\n      );\r\n    }\r\n\r\n    // 3. Check local provider registry\r\n    const provider = this.providers.get(token);\r\n    if (provider) {\r\n      this.resolving.add(token);\r\n      try {\r\n        const instance = this.instantiate(provider) as T;\r\n        this.instances.set(token, instance);\r\n        return instance;\r\n      } finally {\r\n        this.resolving.delete(token);\r\n      }\r\n    }\r\n\r\n    // 4. Handle InjectionToken with a factory (self-providing tokens)\r\n    if (token instanceof InjectionToken && token.options?.factory) {\r\n      const instance = runInContext(this, token.options.factory) as T;\r\n      this.instances.set(token, instance);\r\n      return instance;\r\n    }\r\n\r\n    // 5. Handle @Injectable classes with providedIn: 'root' / this injector\r\n    if (typeof token === 'function') {\r\n      const meta = INJECTABLE_META.get(token as new (...args: unknown[]) => unknown);\r\n      if (meta) {\r\n        const targetInjector = this.resolveProvidedIn(meta.providedIn);\r\n        if (targetInjector === this) {\r\n          this.resolving.add(token);\r\n          try {\r\n            const instance = this.instantiateClass(\r\n              token as new (...args: unknown[]) => T,\r\n              meta.deps\r\n            );\r\n            this.instances.set(token, instance);\r\n            return instance;\r\n          } finally {\r\n            this.resolving.delete(token);\r\n          }\r\n        } else if (targetInjector) {\r\n          // Delegate to the appropriate injector in the tree\r\n          return targetInjector.resolve(token);\r\n        }\r\n      }\r\n    }\r\n\r\n    // 6. Delegate to parent\r\n    if (this.parent) {\r\n      return this.parent.resolve(token);\r\n    }\r\n\r\n    return NOT_FOUND as typeof NOT_FOUND;\r\n  }\r\n\r\n  private instantiate<T>(provider: Provider<T>): T {\r\n    if ('useValue' in provider) {\r\n      return provider.useValue;\r\n    }\r\n\r\n    if ('useExisting' in provider) {\r\n      return this.get(provider.useExisting);\r\n    }\r\n\r\n    if ('useFactory' in provider) {\r\n      const deps = (provider.deps ?? []).map(dep => this.get(dep));\r\n      return provider.useFactory(...deps) as T;\r\n    }\r\n\r\n    // useClass\r\n    const deps = (provider.deps ?? []).map(dep => this.get(dep));\r\n    return new provider.useClass(...deps) as T;\r\n  }\r\n\r\n  private instantiateClass<T>(\r\n    ctor: new (...args: unknown[]) => T,\r\n    deps: Token<unknown>[]\r\n  ): T {\r\n    const resolved = deps.map(dep => this.get(dep));\r\n    return new ctor(...resolved);\r\n  }\r\n\r\n  private resolveProvidedIn(providedIn: ProvidedIn): Injector | null {\r\n    if (providedIn === 'root') return getRootInjector();\r\n    if (providedIn === 'component') return this;\r\n    if (providedIn instanceof Injector) return providedIn;\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Creates a child injector that inherits from this one.\r\n   * Child providers shadow parent providers for the same token.\r\n   */\r\n  createChild(providers: Provider<unknown>[] = []): Injector {\r\n    return new Injector(providers, this);\r\n  }\r\n\r\n  /**\r\n   * Destroys this injector — calls onDestroy() on any instances that\r\n   * implement it, then clears all cached instances.\r\n   */\r\n  destroy(): void {\r\n    for (const instance of this.instances.values()) {\r\n      if (\r\n        instance !== null &&\r\n        typeof instance === 'object' &&\r\n        typeof (instance as { onDestroy?: () => void }).onDestroy === 'function'\r\n      ) {\r\n        (instance as { onDestroy: () => void }).onDestroy();\r\n      }\r\n    }\r\n    this.instances.clear();\r\n    this.providers.clear();\r\n  }\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Root injector (app-level singleton)\r\n// ---------------------------------------------------------------------------\r\n\r\nlet _rootInjector: Injector | null = null;\r\n\r\nexport function getRootInjector(): Injector {\r\n  if (!_rootInjector) {\r\n    _rootInjector = new Injector();\r\n  }\r\n  return _rootInjector;\r\n}\r\n\r\n/**\r\n * Bootstraps the application by creating the root injector with the given\r\n * providers. Should be called once at app startup.\r\n *\r\n * @example\r\n * bootstrapApp([\r\n *   { provide: API_URL, useValue: 'https://api.example.com' },\r\n * ]);\r\n */\r\nexport function bootstrapApp(providers: Provider<unknown>[] = []): Injector {\r\n  _rootInjector = new Injector(providers);\r\n  return _rootInjector;\r\n}\r\n\r\n/** Resets the root injector — primarily useful in tests. */\r\nexport function resetRootInjector(): void {\r\n  _rootInjector?.destroy();\r\n  _rootInjector = null;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Injection context\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * The active injector context for inject() calls.\r\n * Set during component/service instantiation.\r\n */\r\nlet activeInjector: Injector | null = null;\r\n\r\n/**\r\n * Runs a function within a specific injector context, making inject() calls\r\n * inside resolve against that injector.\r\n */\r\nexport function runInContext<T>(injector: Injector, fn: () => T): T {\r\n  const prev = activeInjector;\r\n  activeInjector = injector;\r\n  try {\r\n    return fn();\r\n  } finally {\r\n    activeInjector = prev;\r\n  }\r\n}\r\n\r\n/**\r\n * Returns the currently active injector, or null if called outside an\r\n * injection context.\r\n */\r\nexport function getActiveInjector(): Injector | null {\r\n  return activeInjector;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// inject()\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Resolves a token from the current injection context.\r\n * Must be called during component or service construction.\r\n *\r\n * @example\r\n * \\@Injectable({ providedIn: 'root' })\r\n * class DashboardComponent {\r\n *   private users = inject(UserService);\r\n *   private apiUrl = inject(API_URL);\r\n * }\r\n */\r\nexport function inject<T>(token: Token<T>, options?: { optional?: false }): T;\r\nexport function inject<T>(token: Token<T>, options: { optional: true }): T | null;\r\nexport function inject<T>(\r\n  token: Token<T>,\r\n  options: { optional?: boolean } = {}\r\n): T | null {\r\n  if (!activeInjector) {\r\n    throw new Error(\r\n      `[Vorra DI] inject() called outside of an injection context. ` +\r\n      `inject() can only be used during component or service construction.`\r\n    );\r\n  }\r\n  return activeInjector.get(token, options.optional as true) as T | null;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// Helper: resolve token display name for error messages\r\n// ---------------------------------------------------------------------------\r\n\r\nfunction tokenName(token: Token<unknown>): string {\r\n  if (token instanceof InjectionToken) return token.toString();\r\n  if (typeof token === 'function') return token.name || '(anonymous class)';\r\n  return String(token);\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// onDestroy() — lifecycle hook helper for services\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Registers a cleanup callback to run when the injector that owns this\r\n * service instance is destroyed.\r\n *\r\n * Call this inside a service constructor (within an injection context).\r\n *\r\n * @example\r\n * \\@Injectable({ providedIn: 'root' })\r\n * class WebSocketService {\r\n *   #ws: WebSocket;\r\n *   constructor() {\r\n *     this.#ws = new WebSocket('wss://...');\r\n *     onDestroy(() => this.#ws.close());\r\n *   }\r\n * }\r\n */\r\nexport function onDestroy(fn: () => void): void {\r\n  if (!activeInjector) {\r\n    throw new Error('[Vorra DI] onDestroy() must be called within an injection context.');\r\n  }\r\n  // Attach the cleanup to a sentinel object in the injector under a unique token\r\n  const token = new InjectionToken<DestroyRef>(`__destroyRef__`);\r\n  // We piggyback on a shared DestroyRef list attached to the active injector\r\n  getOrCreateDestroyRef(activeInjector).callbacks.push(fn);\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// DestroyRef — internal lifecycle tracking\r\n// ---------------------------------------------------------------------------\r\n\r\ninterface DestroyRef {\r\n  callbacks: (() => void)[];\r\n}\r\n\r\nconst destroyRefs = new WeakMap<Injector, DestroyRef>();\r\n\r\nfunction getOrCreateDestroyRef(injector: Injector): DestroyRef {\r\n  if (!destroyRefs.has(injector)) {\r\n    destroyRefs.set(injector, { callbacks: [] });\r\n  }\r\n  return destroyRefs.get(injector)!;\r\n}\r\n\r\n/**\r\n * Runs all onDestroy callbacks registered against an injector.\r\n * Called automatically by Injector.destroy(), but also exported for\r\n * use in the component runtime.\r\n */\r\nexport function runDestroyCallbacks(injector: Injector): void {\r\n  const ref = destroyRefs.get(injector);\r\n  if (ref) {\r\n    for (const cb of ref.callbacks) cb();\r\n    ref.callbacks = [];\r\n  }\r\n}\r\n"],"mappings":"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"}

package/dist/dom.cjs

@@ -0,0 +1,302 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_reactivity = require("./reactivity.cjs");
+//#region src/dom.ts
+/**
+* Creates a DOM element with the given tag name.
+*
+* @example
+* const div = createElement('div');
+*/
+function createElement(tag) {
+	return document.createElement(tag);
+}
+/**
+* Sets a static attribute on an element.
+*
+* @example
+* setAttr(el, 'class', 'container');
+*/
+function setAttr(el, name, value) {
+	el.setAttribute(name, value);
+}
+/**
+* Sets a DOM property directly (e.g. value, checked, disabled).
+*
+* @example
+* setProp(input, 'value', 'hello');
+*/
+function setProp(el, name, value) {
+	el[name] = value;
+}
+/**
+* Attaches an event listener and returns an EffectHandle to remove it.
+*
+* @example
+* const handle = listen(btn, 'click', () => count.update(n => n + 1));
+* handle.destroy(); // removes listener
+*/
+function listen(el, event, handler) {
+	el.addEventListener(event, handler);
+	return { destroy() {
+		el.removeEventListener(event, handler);
+	} };
+}
+/**
+* Inserts a child node into a parent, optionally before an anchor node.
+*
+* @example
+* insert(container, textNode);
+* insert(list, item, anchor); // insert before anchor
+*/
+function insert(parent, child, anchor) {
+	parent.insertBefore(child, anchor ?? null);
+}
+/**
+* Removes a node from the DOM.
+*
+* @example
+* remove(el);
+*/
+function remove(node) {
+	node.parentNode?.removeChild(node);
+}
+/**
+* Binds a getter to a Text node's content. The text updates surgically
+* whenever the getter's signal dependencies change.
+*
+* @example
+* const t = document.createTextNode('');
+* bindText(t, () => String(count()));
+*/
+function bindText(node, getter) {
+	return require_reactivity.effect(() => {
+		node.nodeValue = getter();
+	});
+}
+/**
+* Binds a getter to an element attribute. When the getter returns `null`,
+* the attribute is removed.
+*
+* @example
+* bindAttr(el, 'disabled', () => isDisabled() ? '' : null);
+*/
+function bindAttr(el, name, getter) {
+	return require_reactivity.effect(() => {
+		const value = getter();
+		if (value === null) el.removeAttribute(name);
+		else el.setAttribute(name, value);
+	});
+}
+/**
+* Binds a getter to a DOM property. Updates the property directly whenever
+* the getter's signal dependencies change.
+*
+* @example
+* bindProp(input, 'value', () => name());
+*/
+function bindProp(el, name, getter) {
+	return require_reactivity.effect(() => {
+		el[name] = getter();
+	});
+}
+/**
+* Binds a getter to element visibility. When the getter returns `false`,
+* `display: none` is applied; otherwise the inline style is cleared.
+*
+* @example
+* bindShow(el, () => isVisible());
+*/
+function bindShow(el, getter) {
+	return require_reactivity.effect(() => {
+		el.style.display = getter() ? "" : "none";
+	});
+}
+/**
+* Binds a getter to a set of CSS classes. Each key in the record is a class
+* name; when the value is `true` the class is added, when `false` it is
+* removed. Classes not in the record are left untouched.
+*
+* @example
+* bindClass(el, () => ({ active: isActive(), disabled: isDisabled() }));
+*/
+function bindClass(el, getter) {
+	let prevClasses = {};
+	return require_reactivity.effect(() => {
+		const next = getter();
+		for (const name of Object.keys(prevClasses)) if (prevClasses[name] === true && !next[name]) el.classList.remove(name);
+		for (const [name, active] of Object.entries(next)) if (active) el.classList.add(name);
+		else el.classList.remove(name);
+		prevClasses = next;
+	});
+}
+/**
+* Reactively renders a list of items before an anchor comment node.
+* Each item receives its own `ComponentContext` scoped under `parentCtx`
+* so that bindings created inside the item template are properly cleaned
+* up whenever the list re-renders.
+*
+* This is the runtime backing for the `@for` template directive.
+*
+* @example
+* // Generated by: <li @for={item of items()}>…</li>
+* const anchor = document.createComment('for');
+* insert(container, anchor);
+* ctx.effects.push(bindList(anchor, ctx, () => items(), (item, i, itemCtx) => {
+*   const li = createElement('li');
+*   const t = document.createTextNode('');
+*   itemCtx.effects.push(bindText(t, () => item.name));
+*   insert(li, t);
+*   return li;
+* }));
+*/
+function bindList(anchor, parentCtx, getter, itemFactory) {
+	let activeItems = [];
+	return require_reactivity.effect(() => {
+		const list = getter();
+		const parent = anchor.parentNode;
+		if (!parent) return;
+		for (const { node, ctx } of activeItems) {
+			parent.removeChild(node);
+			const idx = parentCtx.children.indexOf(ctx);
+			if (idx >= 0) parentCtx.children.splice(idx, 1);
+			destroyComponent(ctx);
+		}
+		activeItems = [];
+		for (let i = 0; i < list.length; i++) {
+			const itemCtx = createComponent(parentCtx.injector);
+			parentCtx.children.push(itemCtx);
+			const node = itemFactory(list[i], i, itemCtx);
+			parent.insertBefore(node, anchor);
+			activeItems.push({
+				node,
+				ctx: itemCtx
+			});
+		}
+	});
+}
+/**
+* Creates a ComponentContext scoped to a child injector derived from
+* `parentInjector`. The context owns all EffectHandles created during
+* the component's lifetime.
+*
+* @example
+* const ctx = createComponent(app, [{ provide: MY_TOKEN, useValue: 42 }]);
+*/
+function createComponent(parentInjector, providers) {
+	return {
+		injector: parentInjector.createChild(providers ?? []),
+		effects: [],
+		children: []
+	};
+}
+/**
+* Tears down a ComponentContext: destroys all child contexts recursively,
+* then destroys all owned effects, then destroys the injector.
+*
+* @example
+* destroyComponent(ctx);
+*/
+function destroyComponent(ctx) {
+	for (const child of ctx.children) destroyComponent(child);
+	ctx.children.length = 0;
+	for (const handle of ctx.effects) handle.destroy();
+	ctx.effects.length = 0;
+	ctx.injector.destroy();
+}
+/**
+* Mounts a compiled component factory into a container element. The factory
+* receives the ComponentContext, builds the DOM subtree, and returns the
+* root node which is then appended to the container.
+*
+* @example
+* mountComponent(counterFactory, document.getElementById('app')!, ctx);
+*/
+function mountComponent(factory, container, ctx) {
+	const node = factory(ctx);
+	container.appendChild(node);
+}
+/**
+* Instantiates a child component inside a parent's template. Creates a child
+* ComponentContext scoped under the parent, registers it for lifecycle
+* tracking, invokes the factory with the given props, and returns the root
+* DOM node so the caller can insert it into the tree.
+*
+* Props are always passed as getter functions so both static and reactive
+* values share a uniform call-site API: `props['label']()`.
+*
+* @example
+* // In a compiled parent template:
+* const _e1 = mountChild(MyButton, ctx, { label: () => 'Click me' });
+* insert(_e0, _e1);
+*/
+function mountChild(factory, parentCtx, props = {}) {
+	const childCtx = createComponent(parentCtx.injector);
+	parentCtx.children.push(childCtx);
+	const node = factory(childCtx, props);
+	const hmrId = factory["__hmrId"];
+	if (hmrId) {
+		const hmr = (typeof window !== "undefined" ? window : null)?.["__vorra_hmr"];
+		if (hmr?.instances) {
+			const list = hmr.instances.get(hmrId) ?? [];
+			list.push({
+				node,
+				ctx: childCtx,
+				props,
+				parentCtx
+			});
+			hmr.instances.set(hmrId, list);
+		}
+	}
+	return node;
+}
+/**
+* Replaces all mounted instances of the component identified by `id` with
+* the output of `newFactory`. Called by the HMR client when a `.vorra` chunk
+* is hot-updated. Not intended for use in application code.
+*/
+function hmrAccept(id, newFactory) {
+	const hmr = (typeof window !== "undefined" ? window : null)?.["__vorra_hmr"];
+	if (!hmr?.instances) return;
+	const instances = hmr.instances.get(id) ?? [];
+	for (const inst of instances) {
+		const parent = inst.node.parentNode;
+		if (!parent) continue;
+		const nextSibling = inst.node.nextSibling;
+		destroyComponent(inst.ctx);
+		parent.removeChild(inst.node);
+		const newCtx = createComponent(inst.parentCtx.injector);
+		const idx = inst.parentCtx.children.indexOf(inst.ctx);
+		if (idx >= 0) inst.parentCtx.children[idx] = newCtx;
+		const newNode = newFactory(newCtx, inst.props);
+		parent.insertBefore(newNode, nextSibling);
+		inst.node = newNode;
+		inst.ctx = newCtx;
+	}
+}
+if (typeof __vorra_dev !== "undefined" && __vorra_dev && typeof window !== "undefined") {
+	const w = window;
+	if (!w["__vorra_hmr"]) w["__vorra_hmr"] = {};
+	const hmr = w["__vorra_hmr"];
+	if (!hmr["instances"]) hmr["instances"] = /* @__PURE__ */ new Map();
+	hmr["accept"] = hmrAccept;
+}
+//#endregion
+exports.bindAttr = bindAttr;
+exports.bindClass = bindClass;
+exports.bindList = bindList;
+exports.bindProp = bindProp;
+exports.bindShow = bindShow;
+exports.bindText = bindText;
+exports.createComponent = createComponent;
+exports.createElement = createElement;
+exports.destroyComponent = destroyComponent;
+exports.hmrAccept = hmrAccept;
+exports.insert = insert;
+exports.listen = listen;
+exports.mountChild = mountChild;
+exports.mountComponent = mountComponent;
+exports.remove = remove;
+exports.setAttr = setAttr;
+exports.setProp = setProp;
+
+//# sourceMappingURL=dom.cjs.map

package/dist/dom.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.cjs","names":["effect"],"sources":["../src/dom.ts"],"sourcesContent":["// =============================================================================\r\n// Vorra Runtime DOM Layer\r\n// Direct DOM operations + reactive bindings that compiled templates call into.\r\n// =============================================================================\r\n\r\nimport { effect } from './reactivity.js';\r\nimport type { EffectHandle } from './reactivity.js';\r\nimport { Injector } from './di.js';\r\nimport type { Provider } from './di.js';\r\n\r\n// ---------------------------------------------------------------------------\r\n// Types\r\n// ---------------------------------------------------------------------------\r\n\r\nexport interface ComponentContext {\r\n  injector: Injector;\r\n  effects: EffectHandle[];\r\n  children: ComponentContext[];\r\n}\r\n\r\n// Injected as a compile-time constant by Rolldown `define` in dev mode.\r\n// `typeof` check is intentional — the variable may not be defined at runtime.\r\ndeclare const __vorra_dev: boolean | undefined;\r\n\r\n/** Internal record of a mounted component instance, used by HMR swapping. */\r\ninterface HMRInstance {\r\n  node: Node;\r\n  ctx: ComponentContext;\r\n  props: Record<string, () => unknown>;\r\n  parentCtx: ComponentContext;\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// 5.1 Element creation & patching\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Creates a DOM element with the given tag name.\r\n *\r\n * @example\r\n * const div = createElement('div');\r\n */\r\nexport function createElement(tag: string): Element {\r\n  return document.createElement(tag);\r\n}\r\n\r\n/**\r\n * Sets a static attribute on an element.\r\n *\r\n * @example\r\n * setAttr(el, 'class', 'container');\r\n */\r\nexport function setAttr(el: Element, name: string, value: string): void {\r\n  el.setAttribute(name, value);\r\n}\r\n\r\n/**\r\n * Sets a DOM property directly (e.g. value, checked, disabled).\r\n *\r\n * @example\r\n * setProp(input, 'value', 'hello');\r\n */\r\nexport function setProp(el: Element, name: string, value: unknown): void {\r\n  (el as unknown as Record<string, unknown>)[name] = value;\r\n}\r\n\r\n/**\r\n * Attaches an event listener and returns an EffectHandle to remove it.\r\n *\r\n * @example\r\n * const handle = listen(btn, 'click', () => count.update(n => n + 1));\r\n * handle.destroy(); // removes listener\r\n */\r\nexport function listen(\r\n  el: Element,\r\n  event: string,\r\n  handler: EventListener\r\n): EffectHandle {\r\n  el.addEventListener(event, handler);\r\n  return {\r\n    destroy() {\r\n      el.removeEventListener(event, handler);\r\n    },\r\n  };\r\n}\r\n\r\n/**\r\n * Inserts a child node into a parent, optionally before an anchor node.\r\n *\r\n * @example\r\n * insert(container, textNode);\r\n * insert(list, item, anchor); // insert before anchor\r\n */\r\nexport function insert(parent: Node, child: Node, anchor?: Node | null): void {\r\n  parent.insertBefore(child, anchor ?? null);\r\n}\r\n\r\n/**\r\n * Removes a node from the DOM.\r\n *\r\n * @example\r\n * remove(el);\r\n */\r\nexport function remove(node: Node): void {\r\n  node.parentNode?.removeChild(node);\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// 5.2 Reactive bindings\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Binds a getter to a Text node's content. The text updates surgically\r\n * whenever the getter's signal dependencies change.\r\n *\r\n * @example\r\n * const t = document.createTextNode('');\r\n * bindText(t, () => String(count()));\r\n */\r\nexport function bindText(node: Text, getter: () => string): EffectHandle {\r\n  return effect(() => {\r\n    node.nodeValue = getter();\r\n  });\r\n}\r\n\r\n/**\r\n * Binds a getter to an element attribute. When the getter returns `null`,\r\n * the attribute is removed.\r\n *\r\n * @example\r\n * bindAttr(el, 'disabled', () => isDisabled() ? '' : null);\r\n */\r\nexport function bindAttr(\r\n  el: Element,\r\n  name: string,\r\n  getter: () => string | null\r\n): EffectHandle {\r\n  return effect(() => {\r\n    const value = getter();\r\n    if (value === null) {\r\n      el.removeAttribute(name);\r\n    } else {\r\n      el.setAttribute(name, value);\r\n    }\r\n  });\r\n}\r\n\r\n/**\r\n * Binds a getter to a DOM property. Updates the property directly whenever\r\n * the getter's signal dependencies change.\r\n *\r\n * @example\r\n * bindProp(input, 'value', () => name());\r\n */\r\nexport function bindProp(\r\n  el: Element,\r\n  name: string,\r\n  getter: () => unknown\r\n): EffectHandle {\r\n  return effect(() => {\r\n    (el as unknown as Record<string, unknown>)[name] = getter();\r\n  });\r\n}\r\n\r\n/**\r\n * Binds a getter to element visibility. When the getter returns `false`,\r\n * `display: none` is applied; otherwise the inline style is cleared.\r\n *\r\n * @example\r\n * bindShow(el, () => isVisible());\r\n */\r\nexport function bindShow(el: Element, getter: () => boolean): EffectHandle {\r\n  return effect(() => {\r\n    (el as HTMLElement).style.display = getter() ? '' : 'none';\r\n  });\r\n}\r\n\r\n/**\r\n * Binds a getter to a set of CSS classes. Each key in the record is a class\r\n * name; when the value is `true` the class is added, when `false` it is\r\n * removed. Classes not in the record are left untouched.\r\n *\r\n * @example\r\n * bindClass(el, () => ({ active: isActive(), disabled: isDisabled() }));\r\n */\r\nexport function bindClass(\r\n  el: Element,\r\n  getter: () => Record<string, boolean>\r\n): EffectHandle {\r\n  let prevClasses: Record<string, boolean> = {};\r\n\r\n  return effect(() => {\r\n    const next = getter();\r\n\r\n    // Remove classes that were previously active but are no longer present or are now false.\r\n    for (const name of Object.keys(prevClasses)) {\r\n      if (prevClasses[name] === true && !next[name]) {\r\n        el.classList.remove(name);\r\n      }\r\n    }\r\n\r\n    // Add/remove based on current values.\r\n    for (const [name, active] of Object.entries(next)) {\r\n      if (active) {\r\n        el.classList.add(name);\r\n      } else {\r\n        el.classList.remove(name);\r\n      }\r\n    }\r\n\r\n    prevClasses = next;\r\n  });\r\n}\r\n\r\n/**\r\n * Reactively renders a list of items before an anchor comment node.\r\n * Each item receives its own `ComponentContext` scoped under `parentCtx`\r\n * so that bindings created inside the item template are properly cleaned\r\n * up whenever the list re-renders.\r\n *\r\n * This is the runtime backing for the `@for` template directive.\r\n *\r\n * @example\r\n * // Generated by: <li @for={item of items()}>…</li>\r\n * const anchor = document.createComment('for');\r\n * insert(container, anchor);\r\n * ctx.effects.push(bindList(anchor, ctx, () => items(), (item, i, itemCtx) => {\r\n *   const li = createElement('li');\r\n *   const t = document.createTextNode('');\r\n *   itemCtx.effects.push(bindText(t, () => item.name));\r\n *   insert(li, t);\r\n *   return li;\r\n * }));\r\n */\r\nexport function bindList<T>(\r\n  anchor: Comment,\r\n  parentCtx: ComponentContext,\r\n  getter: () => T[],\r\n  itemFactory: (item: T, index: number, ctx: ComponentContext) => Node,\r\n): EffectHandle {\r\n  let activeItems: Array<{ node: Node; ctx: ComponentContext }> = [];\r\n\r\n  return effect(() => {\r\n    const list = getter();\r\n    const parent = anchor.parentNode;\r\n    if (!parent) return;\r\n\r\n    // Tear down previous iteration: remove DOM nodes and destroy child contexts.\r\n    for (const { node, ctx } of activeItems) {\r\n      parent.removeChild(node);\r\n      const idx = parentCtx.children.indexOf(ctx);\r\n      if (idx >= 0) parentCtx.children.splice(idx, 1);\r\n      destroyComponent(ctx);\r\n    }\r\n    activeItems = [];\r\n\r\n    // Render each new item and insert it before the anchor.\r\n    for (let i = 0; i < list.length; i++) {\r\n      const itemCtx = createComponent(parentCtx.injector);\r\n      parentCtx.children.push(itemCtx);\r\n      const node = itemFactory(list[i]!, i, itemCtx);\r\n      parent.insertBefore(node, anchor);\r\n      activeItems.push({ node, ctx: itemCtx });\r\n    }\r\n  });\r\n}\r\n\r\n// ---------------------------------------------------------------------------\r\n// 5.3 Component lifecycle\r\n// ---------------------------------------------------------------------------\r\n\r\n/**\r\n * Creates a ComponentContext scoped to a child injector derived from\r\n * `parentInjector`. The context owns all EffectHandles created during\r\n * the component's lifetime.\r\n *\r\n * @example\r\n * const ctx = createComponent(app, [{ provide: MY_TOKEN, useValue: 42 }]);\r\n */\r\nexport function createComponent(\r\n  parentInjector: Injector,\r\n  providers?: Provider[]\r\n): ComponentContext {\r\n  const injector = parentInjector.createChild(providers ?? []);\r\n  return {\r\n    injector,\r\n    effects: [],\r\n    children: [],\r\n  };\r\n}\r\n\r\n/**\r\n * Tears down a ComponentContext: destroys all child contexts recursively,\r\n * then destroys all owned effects, then destroys the injector.\r\n *\r\n * @example\r\n * destroyComponent(ctx);\r\n */\r\nexport function destroyComponent(ctx: ComponentContext): void {\r\n  // Recursively destroy children first.\r\n  for (const child of ctx.children) {\r\n    destroyComponent(child);\r\n  }\r\n  ctx.children.length = 0;\r\n\r\n  // Destroy all owned effect handles.\r\n  for (const handle of ctx.effects) {\r\n    handle.destroy();\r\n  }\r\n  ctx.effects.length = 0;\r\n\r\n  // Tear down the scoped injector.\r\n  ctx.injector.destroy();\r\n}\r\n\r\n/**\r\n * Mounts a compiled component factory into a container element. The factory\r\n * receives the ComponentContext, builds the DOM subtree, and returns the\r\n * root node which is then appended to the container.\r\n *\r\n * @example\r\n * mountComponent(counterFactory, document.getElementById('app')!, ctx);\r\n */\r\nexport function mountComponent(\r\n  factory: (ctx: ComponentContext, props?: Record<string, () => unknown>) => Node,\r\n  container: Element,\r\n  ctx: ComponentContext\r\n): void {\r\n  const node = factory(ctx);\r\n  container.appendChild(node);\r\n}\r\n\r\n/**\r\n * Instantiates a child component inside a parent's template. Creates a child\r\n * ComponentContext scoped under the parent, registers it for lifecycle\r\n * tracking, invokes the factory with the given props, and returns the root\r\n * DOM node so the caller can insert it into the tree.\r\n *\r\n * Props are always passed as getter functions so both static and reactive\r\n * values share a uniform call-site API: `props['label']()`.\r\n *\r\n * @example\r\n * // In a compiled parent template:\r\n * const _e1 = mountChild(MyButton, ctx, { label: () => 'Click me' });\r\n * insert(_e0, _e1);\r\n */\r\nexport function mountChild(\r\n  factory: (ctx: ComponentContext, props: Record<string, () => unknown>) => Node,\r\n  parentCtx: ComponentContext,\r\n  props: Record<string, () => unknown> = {},\r\n): Node {\r\n  const childCtx = createComponent(parentCtx.injector);\r\n  parentCtx.children.push(childCtx);\r\n  const node = factory(childCtx, props);\r\n\r\n  // Register the instance for HMR swapping when the runtime is active.\r\n  const hmrId = (factory as unknown as Record<string, unknown>)['__hmrId'] as string | undefined;\r\n  if (hmrId) {\r\n    const w = typeof window !== 'undefined' ? (window as unknown as Record<string, unknown>) : null;\r\n    const hmr = w?.['__vorra_hmr'] as { instances?: Map<string, HMRInstance[]> } | undefined;\r\n    if (hmr?.instances) {\r\n      const list = hmr.instances.get(hmrId) ?? [];\r\n      list.push({ node, ctx: childCtx, props, parentCtx });\r\n      hmr.instances.set(hmrId, list);\r\n    }\r\n  }\r\n\r\n  return node;\r\n}\r\n\r\n/**\r\n * Replaces all mounted instances of the component identified by `id` with\r\n * the output of `newFactory`. Called by the HMR client when a `.vorra` chunk\r\n * is hot-updated. Not intended for use in application code.\r\n */\r\nexport function hmrAccept(\r\n  id: string,\r\n  newFactory: (ctx: ComponentContext, props: Record<string, () => unknown>) => Node,\r\n): void {\r\n  const w = typeof window !== 'undefined' ? (window as unknown as Record<string, unknown>) : null;\r\n  const hmr = w?.['__vorra_hmr'] as { instances?: Map<string, HMRInstance[]> } | undefined;\r\n  if (!hmr?.instances) return;\r\n\r\n  const instances = hmr.instances.get(id) ?? [];\r\n  for (const inst of instances) {\r\n    const parent = inst.node.parentNode;\r\n    if (!parent) continue; // component was unmounted — skip\r\n\r\n    const nextSibling = inst.node.nextSibling;\r\n\r\n    // Tear down old component subtree.\r\n    destroyComponent(inst.ctx);\r\n    parent.removeChild(inst.node);\r\n\r\n    // Mount the new factory in its place.\r\n    const newCtx = createComponent(inst.parentCtx.injector);\r\n    const idx = inst.parentCtx.children.indexOf(inst.ctx);\r\n    if (idx >= 0) inst.parentCtx.children[idx] = newCtx;\r\n\r\n    const newNode = newFactory(newCtx, inst.props);\r\n    parent.insertBefore(newNode, nextSibling);\r\n\r\n    // Update the instance record for future HMR swaps.\r\n    inst.node = newNode;\r\n    inst.ctx = newCtx;\r\n  }\r\n}\r\n\r\n// Wire up the HMR runtime on the global `window.__vorra_hmr` object so that\r\n// dynamically-imported component chunks can call `window.__vorra_hmr.accept`.\r\n// This block is compiled away in production builds (Rolldown replaces\r\n// `__vorra_dev` with `false` and tree-shakes the dead code).\r\nif (typeof __vorra_dev !== 'undefined' && __vorra_dev && typeof window !== 'undefined') {\r\n  const w = window as unknown as Record<string, unknown>;\r\n  if (!w['__vorra_hmr']) w['__vorra_hmr'] = {};\r\n  const hmr = w['__vorra_hmr'] as Record<string, unknown>;\r\n  if (!hmr['instances']) hmr['instances'] = new Map<string, HMRInstance[]>();\r\n  hmr['accept'] = hmrAccept;\r\n}\r\n"],"mappings":"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"}