@jqhtml/core 2.3.72 → 2.3.75

package/dist/cache-key-serializer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache-key-serializer.d.ts","sourceRoot":"","sources":["../src/cache-key-serializer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,MAAM,gBAAgB,GACxB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC1B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC;;;;GAIG;AACH,eAAO,MAAM,aAAa,MAAM,CAAC;AA8FjC;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,GAAG,GAAG,gBAAgB,CAWpE"}
+{"version":3,"file":"cache-key-serializer.d.ts","sourceRoot":"","sources":["../src/cache-key-serializer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,MAAM,gBAAgB,GACxB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC1B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC;;;;GAIG;AACH,eAAO,MAAM,aAAa,MAAM,CAAC;AAyGjC;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,GAAG,GAAG,gBAAgB,CASpE"}

package/dist/component-cache.d.ts

@@ -3,7 +3,7 @@
  *
  * Extracted from component.ts - handles cache key generation,
  * cache reads during create(), cache checks during reload(),
- * and HTML cache snapshots during ready().
+ * and HTML cache snapshots during ready() and reload().
  *
  * Uses Jqhtml_Local_Storage as the underlying storage layer.
  */
@@ -32,6 +32,16 @@ export declare function generate_cache_key(component: any): Cache_Key_Result;
  * Controlled by the `warn_uncacheable_args` integration flag (see config.ts).
  */
 export declare function warn_uncacheable_component(component: any, uncacheable_property?: string, uncacheable_reason?: string): void;
+/**
+ * Keep the element's `data-nocache` marker in step with a cache key result. Boot,
+ * `load()` and `reload()` all call this with the key they just computed, so the marker
+ * always describes the CURRENT args:
+ *
+ *   key        - remove any `data-nocache` (args that were unkeyable are keyable again)
+ *   no key     - `data-nocache="<arg>:<reason>"`, plus the dev warning when `warn` is set
+ *                (itself gated by `warn_uncacheable_args`, once per component+arg+reason)
+ */
+export declare function mark_cacheability(component: any, result: Cache_Key_Result, warn?: boolean): void;
 /**
  * An HTML-cache entry: the inner HTML of a component plus the cid it was rendered
  * under. Scoped ids inside the markup are "<name>:<cid>", so the owner's cid is what
@@ -49,27 +59,42 @@ export interface Html_Cache_Snapshot {
  */
 export declare function read_cache_in_create(component: any): void;
 /**
- * Check cache during reload() when args have changed.
- * If cache hit, hydrates data/html and triggers an immediate render.
+ * Refresh the cache key at the start of every reload(), then - if args have changed -
+ * check the cache. On a hit, hydrates data/html and triggers an immediate render.
+ *
+ * The recomputed key is ALWAYS assigned, null included: every cache write later in the
+ * reload (data after on_load(), the html snapshot after render) goes to _cache_key, so
+ * a key left over from the previous args would file the new args' content under the
+ * old args' entry.
  *
  * @param component - The component instance
+ * @param args_changed - Whether this.args differ from the last render's
  * @returns true if rendered from cache, false otherwise
  */
-export declare function check_cache_on_reload(component: any): boolean;
+export declare function check_cache_on_reload(component: any, args_changed: boolean): boolean;
 /**
- * Write HTML cache snapshot during ready() phase.
- * Only caches if the component is dynamic (data changed during on_load).
+ * Write HTML cache snapshot during ready() phase, and at the end of a reload() that
+ * loaded changed data. Only caches if the component is dynamic (data changed during
+ * on_load).
  *
  * @param component - The component instance
  */
 export declare function write_html_cache_snapshot(component: any): void;
 /**
- * Write data/HTML to cache after on_load() completes.
+ * Write data/HTML to cache after on_load() completes, and set component._is_dynamic.
  * Called from _apply_load_result().
  *
+ * A load is written when its data changed to something other than the empty '{}', OR
+ * when its data is unchanged but the cache key moved: a reload() with new args whose
+ * data equals the previous load's must still file that data under the new key, or a
+ * later boot with those args misses. Same key and unchanged data writes nothing.
+ * component._data_cache_key is the key the current this.data is cached under (written
+ * or hydrated from), null when it is not cached.
+ *
  * @param component - The component instance
  * @param data_changed - Whether this.data changed during on_load
+ * @param data_text - this.data's serialized text (what it was normalized through)
  */
-export declare function write_cache_on_loaded(component: any, data_changed: boolean): void;
+export declare function write_cache_on_loaded(component: any, data_changed: boolean, data_text: string): void;
 export {};
 //# sourceMappingURL=component-cache.d.ts.map

package/dist/component-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component-cache.d.ts","sourceRoot":"","sources":["../src/component-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH;;GAEG;AACH,UAAU,gBAAgB;IACxB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,GAAG,GAAG,gBAAgB,CAsBnE;AAKD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,GAAG,EACd,oBAAoB,CAAC,EAAE,MAAM,EAC7B,kBAAkB,CAAC,EAAE,MAAM,GAC1B,IAAI,CAmDN;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAoBD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,GAAG,GAAG,IAAI,CAqGzD;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,GAAG,GAAG,OAAO,CAqD7D;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,GAAG,GAAG,IAAI,CA+B9D;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,GAAG,EAAE,YAAY,EAAE,OAAO,GAAG,IAAI,CA4BjF"}
+{"version":3,"file":"component-cache.d.ts","sourceRoot":"","sources":["../src/component-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH;;GAEG;AACH,UAAU,gBAAgB;IACxB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,GAAG,GAAG,gBAAgB,CAsBnE;AAKD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,GAAG,EACd,oBAAoB,CAAC,EAAE,MAAM,EAC7B,kBAAkB,CAAC,EAAE,MAAM,GAC1B,IAAI,CAmDN;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,gBAAgB,EAAE,IAAI,GAAE,OAAc,GAAG,IAAI,CAkBtG;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAqBD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,GAAG,GAAG,IAAI,CA+FzD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,GAAG,EAAE,YAAY,EAAE,OAAO,GAAG,OAAO,CA2DpF;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,GAAG,GAAG,IAAI,CAsC9D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,GAAG,EAAE,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAiDpG"}

package/dist/component-events.d.ts

@@ -4,6 +4,10 @@
  * Extracted from component.ts - handles lifecycle event registration,
  * triggering, and state tracking.
  *
+ * Every handler runs with `this` bound to the component and the component as its first
+ * argument, whether it fires from trigger(), as a once() handler, or immediately on
+ * registration (sticky replay).
+ *
  * EVERY event is "sticky", not just the lifecycle ones: trigger() records the event
  * name and its payload, and a handler registered afterwards fires immediately with that
  * last payload. This is deliberate and applies to custom events too - a subscriber that
@@ -25,7 +29,7 @@
  * @param event_name - Name of the event
  * @param callback - Callback: (component, data?) => void
  */
-export declare function event_on(component: any, event_name: string, callback: (comp: any, data?: any) => void): any;
+export declare function event_on(component: any, event_name: string, callback: (this: any, comp: any, data?: any) => void): any;
 /**
  * Register a callback that fires exactly once.
  *
@@ -36,7 +40,7 @@ export declare function event_on(component: any, event_name: string, callback: (
  * @param event_name - Name of the event
  * @param callback - Callback: (component, data?) => void
  */
-export declare function event_once(component: any, event_name: string, callback: (comp: any, data?: any) => void): any;
+export declare function event_once(component: any, event_name: string, callback: (this: any, comp: any, data?: any) => void): any;
 /**
  * Trigger an event - fires all registered callbacks.
  * Marks event as occurred so future .on() calls fire immediately.

package/dist/component-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component-events.d.ts","sourceRoot":"","sources":["../src/component-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,GAAG,CAqB3G;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,GAAG,CA+B7G;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAoBlF;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAG/E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAEzE"}
+{"version":3,"file":"component-events.d.ts","sourceRoot":"","sources":["../src/component-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,GAAG,CAqBtH;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,GAAG,CAsCxH;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAsBlF;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAG/E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAEzE"}

package/dist/component-queue.d.ts

@@ -1,58 +1,113 @@
 /**
  * JQHTML Component Lifecycle Queue
  *
- * Serializes lifecycle operations (render, reload, refresh, load) per component.
- * Replaces _create_debounced_function with a proper queue that:
+ * One lock per component. Serializes boot with render(), load(), reload() and refresh():
  *
- * - At most one operation runs at a time per component
- * - At most one PENDING entry per type; different types queue behind each other FIFO
- * - Same-type pending operations collapse: the newest executor wins, and every
- *   collapsed caller is settled with the value of the executor that actually ran
- * - A caller is settled BEFORE the next pending entry starts
- *
- * Boot bypasses this queue entirely - it runs the lifecycle directly.
+ * - Boot is the first entry. Every entry - boot included - holds the lock from its start
+ *   through the end of its own on_ready(). A call made meanwhile, including one made
+ *   from inside on_ready(), waits and starts after it - unless it is awaited while that
+ *   on_ready() is still running: then promote() runs it at once, nested.
+ * - A call made while the lock is held waits as a pending entry; pending entries run in
+ *   call order, one at a time.
+ * - A new call merges only into the LAST pending entry (never the running one), and only
+ *   when it has the same key (same method, same arguments). The merged caller does not
+ *   run; it settles with the result of the entry it merged into. Different keys never
+ *   merge: reload, refresh, reload stays three entries.
+ * - A caller is settled BEFORE the next pending entry starts.
  */
+export interface Queue_Entry<T = any> {
+    /** Method plus arguments: 'render', 'load', 'reload' (reload(), reload(true)), 'refresh' (refresh(), reload(false)) */
+    key: string;
+    executor: () => Promise<T>;
+    resolvers: Array<(value: T) => void>;
+    rejecters: Array<(error: any) => void>;
+}
 export declare class Component_Queue {
-    /** Currently executing operation */
-    private _current;
+    private _on_idle;
     /**
-     * Operations waiting to run after the current one, in FIFO order.
-     * At most one entry per type: a second reload() while a reload is pending
-     * collapses into it, but a render() queued over a pending reload() is its
-     * own entry and both run. Replacing the older entry (the previous behaviour)
-     * dropped that operation entirely while still resolving its callers as if it
-     * had run.
+     * True while boot or an entry holds the lock - and through the macrotask gap between a
+     * finished entry and the next pending one, so nothing can jump ahead of the queue.
      */
+    private _busy;
+    /** True from begin_boot() until end_boot() */
+    private _booting;
+    /** Entries waiting for the lock, in call order */
     private _pending;
+    /** Promoted entries still running (see promote()) */
+    private _promoted_running;
+    /** The lock holder finished while promoted entries still ran; release when they end */
+    private _release_deferred;
+    /** @param _on_idle - Called whenever the lock is released with nothing waiting */
+    constructor(_on_idle: () => void);
+    /** True while calls are waiting for the lock. */
+    get has_pending(): boolean;
+    /** True while a promoted entry is still running. */
+    get promoted_running(): boolean;
+    /** Boot start: boot is the first entry and takes the lock. */
+    begin_boot(): void;
     /**
-     * Enqueue a lifecycle operation.
-     *
-     * Behavior:
-     * - Nothing running → execute immediately
-     * - Something running, no pending entry of this type → queue one (FIFO)
-     * - Something running, same type pending → collapse: keep every caller, but
-     *   swap in the newest executor ("only the most recent call executes")
-     *
-     * Every caller collapsed onto one entry receives the value that entry's
-     * executor returned - or its error, if it threw.
+     * Boot ended: after its on_ready(), or early (stopped, threw, truncated lifecycle).
+     * Releases the lock. Safe to call more than once.
+     */
+    end_boot(): void;
+    /**
+     * Run `executor` now if the component is idle, otherwise queue it.
      *
-     * @param type - Operation type ('render', 'reload', 'refresh', 'load')
-     * @param executor - The async function to execute
-     * @returns Promise that settles with the result of the execution that ran
+     * @param key - Method plus arguments. Only an identical key merges.
+     * @param executor - The async operation. It reads this.args when it STARTS, so a
+     *                   merged caller gets the newest args.
+     * @returns The promise that settles with the result of the entry that ran, and the
+     *          pending entry the call is waiting on (null when it started at once) - the
+     *          handle promote() takes.
      */
-    enqueue<T>(type: string, executor: () => Promise<T>): Promise<T>;
+    enqueue<T>(key: string, executor: () => Promise<T>): {
+        promise: Promise<T>;
+        entry: Queue_Entry<T> | null;
+    };
     /**
-     * Run one entry, settle its callers, then start the next pending entry.
+     * Run a pending entry NOW, nested inside the cycle that holds the lock: the cycle's
+     * on_ready() is awaiting it, and would otherwise wait forever. The entry leaves the
+     * queue (so no later call merges into it); the lock stays with the running cycle. The
+     * lock is not released while a promoted entry still runs, even when the cycle that
+     * holds it ends first, so nothing queued can start alongside it.
+     * @returns false when the entry is no longer pending (already started or promoted)
+     */
+    promote(entry: Queue_Entry<any>): boolean;
+    /**
+     * Run one entry, settle its callers, then release the lock.
      * @private
      */
     private _run;
     /**
-     * Check if any operation is currently running.
+     * Run an entry's executor and settle its callers. Touches no lock state.
+     * @private
      */
-    get is_busy(): boolean;
+    private _execute;
     /**
-     * Check if there's a pending operation waiting.
+     * Release the lock, or hand it to the next pending entry.
+     * @private
      */
-    get has_pending(): boolean;
+    private _release;
+}
+/**
+ * The promise render(), load(), reload() and refresh() return when they are called while
+ * one of the component's own on_loaded() or on_ready() is running.
+ *
+ * `await` (and any chaining) calls .then() on a non-native promise, so .then() is where
+ * awaiting is seen. The first .then() runs `on_then` once: during on_ready() it pulls the
+ * queued call forward so it runs at once instead of deadlocking; during on_loaded() it
+ * warns (development).
+ *
+ * Derived promises (.then()/.catch()/.finally() results) are plain Promises.
+ */
+export declare class Lifecycle_Call_Promise<T> extends Promise<T> {
+    static get [Symbol.species](): PromiseConstructor;
+    private _on_then;
+    /**
+     * @param promise - The queued call's promise
+     * @param on_then - Run once, on the first .then() (await or chain)
+     */
+    static wrap<T>(promise: Promise<T>, on_then: () => void): Lifecycle_Call_Promise<T>;
+    then<R1 = T, R2 = never>(on_fulfilled?: ((value: T) => R1 | PromiseLike<R1>) | null, on_rejected?: ((reason: any) => R2 | PromiseLike<R2>) | null): Promise<R1 | R2>;
 }
 //# sourceMappingURL=component-queue.d.ts.map

package/dist/component-queue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component-queue.d.ts","sourceRoot":"","sources":["../src/component-queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAUH,qBAAa,eAAe;IAC1B,oCAAoC;IACpC,OAAO,CAAC,QAAQ,CAAiC;IAEjD;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,CAA0B;IAE1C;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IA+BhE;;;OAGG;IACH,OAAO,CAAC,IAAI;IA2CZ;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,IAAI,WAAW,IAAI,OAAO,CAEzB;CACF"}
+{"version":3,"file":"component-queue.d.ts","sourceRoot":"","sources":["../src/component-queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,GAAG;IAClC,uHAAuH;IACvH,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC;IAC3B,SAAS,EAAE,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC;IACrC,SAAS,EAAE,KAAK,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,CAAC;CACxC;AAED,qBAAa,eAAe;IAoBd,OAAO,CAAC,QAAQ;IAnB5B;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAkB;IAE/B,8CAA8C;IAC9C,OAAO,CAAC,QAAQ,CAAkB;IAElC,kDAAkD;IAClD,OAAO,CAAC,QAAQ,CAA0B;IAE1C,qDAAqD;IACrD,OAAO,CAAC,iBAAiB,CAAa;IAEtC,uFAAuF;IACvF,OAAO,CAAC,iBAAiB,CAAkB;IAE3C,kFAAkF;gBAC9D,QAAQ,EAAE,MAAM,IAAI;IAExC,iDAAiD;IACjD,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,oDAAoD;IACpD,IAAI,gBAAgB,IAAI,OAAO,CAE9B;IAED,8DAA8D;IAC9D,UAAU,IAAI,IAAI;IAKlB;;;OAGG;IACH,QAAQ,IAAI,IAAI;IAMhB;;;;;;;;;OASG;IACH,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG;QAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;QAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;KAAE;IA8B1G;;;;;;;OAOG;IACH,OAAO,CAAC,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,GAAG,OAAO;IAezC;;;OAGG;IACH,OAAO,CAAC,IAAI;IAUZ;;;OAGG;YACW,QAAQ;IAWtB;;;OAGG;IACH,OAAO,CAAC,QAAQ;CA8BjB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,sBAAsB,CAAC,CAAC,CAAE,SAAQ,OAAO,CAAC,CAAC,CAAC;IACvD,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,uBAE1B;IAED,OAAO,CAAC,QAAQ,CAA6B;IAE7C;;;OAGG;IACH,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,sBAAsB,CAAC,CAAC,CAAC;IAQnF,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,EACrB,YAAY,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,EAC1D,WAAW,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,GAAG,KAAK,EAAE,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,GAC3D,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;CAQpB"}

package/dist/component-registry.d.ts

@@ -5,7 +5,10 @@
  * Enables dynamic component instantiation and template association
  */
 import { Jqhtml_Component } from './component.js';
-export type TemplateFunction = (this: Jqhtml_Component, data: Record<string, any>, args: Record<string, any>, content: any) => [any[], Jqhtml_Component];
+import { Jqhtml_Markup } from './markup.js';
+export type TemplateFunction = (this: Jqhtml_Component, data: Record<string, any>, args: Record<string, any>, content: any, jqhtml?: any) => Jqhtml_Markup | {
+    _slots: Record<string, (...args: any[]) => Jqhtml_Markup>;
+};
 export interface TemplateDefinition {
     name: string;
     tag: string;
@@ -33,6 +36,22 @@ export declare function register_template(template_def: TemplateDefinition): boo
  * Get template for a component by name
  */
 export declare function get_template(name: string): TemplateDefinition;
+/**
+ * Check a template's `extends=""` against its component's JS class (CLAUDE.md "Template
+ * Inheritance"). Returns an error message on conflict, null otherwise.
+ *
+ * The rule: list the class's JS ancestors up to Jqhtml_Component that have a template of
+ * their own. An empty list (the class extends Jqhtml_Component directly, or only plain
+ * helper classes sit in between) cannot conflict. Otherwise `extends=` must name one of
+ * them - any ancestor, so a template may skip an intermediate layer. A template-only
+ * component (no class registered under the template's name) and an `extends=` target
+ * that has no template (resolution falls back to the prototype chain) are not conflicts.
+ *
+ * @param template_def The template being rendered
+ * @param instance_class The rendering instance's class, used when no class is registered
+ *   under the template's name but the instance's class carries that name
+ */
+export declare function extends_conflict(template_def: TemplateDefinition, instance_class?: any): string | null;
 /**
  * Get template for a component class - walks up inheritance chain
  */

package/dist/component-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"component-registry.d.ts","sourceRoot":"","sources":["../src/component-registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAIlD,MAAM,MAAM,gBAAgB,GAAG,CAC7B,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzB,OAAO,EAAE,GAAG,KACT,CAAC,GAAG,EAAE,EAAE,gBAAgB,CAAC,CAAC;AAG/B,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,gBAAgB,CAAC;CAC1B;AAGD,MAAM,MAAM,oBAAoB,GAAG,KAAK,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,gBAAgB,CAAC;AAsCtG;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,oBAAoB,EACrC,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,IAAI,CAAC;AACR,wBAAgB,kBAAkB,CAAC,eAAe,EAAE,oBAAoB,GAAG,IAAI,CAAC;AA4ChF;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAqClF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,kBAAkB,GAAG,OAAO,CAoC3E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CA0C7D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,eAAe,EAAE,oBAAoB,GAAG,kBAAkB,CAwB/F;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,GAAG,EACb,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAC7B,gBAAgB,CAGlB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAE9C;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,EAAE,CAEnD;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAE,CAAC,CAsB/F;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,kBAAkB,GAAG,oBAAoB,GAAG,IAAI,CAwChF"}
+{"version":3,"file":"component-registry.d.ts","sourceRoot":"","sources":["../src/component-registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAI5C,MAAM,MAAM,gBAAgB,GAAG,CAC7B,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzB,OAAO,EAAE,GAAG,EACZ,MAAM,CAAC,EAAE,GAAG,KACT,aAAa,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,aAAa,CAAC,CAAA;CAAE,CAAC;AAGnF,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,gBAAgB,CAAC;CAC1B;AAGD,MAAM,MAAM,oBAAoB,GAAG,KAAK,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,gBAAgB,CAAC;AAyDtG;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,eAAe,EAAE,oBAAoB,EACrC,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,IAAI,CAAC;AACR,wBAAgB,kBAAkB,CAAC,eAAe,EAAE,oBAAoB,GAAG,IAAI,CAAC;AA8ChF;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAqClF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,kBAAkB,GAAG,OAAO,CAqC3E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CA0C7D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,kBAAkB,EAAE,cAAc,CAAC,EAAE,GAAG,GAAG,MAAM,GAAG,IAAI,CAsCtG;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,eAAe,EAAE,oBAAoB,GAAG,kBAAkB,CA6B/F;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,GAAG,EACb,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAC7B,gBAAgB,CAGlB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAE9C;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,EAAE,CAEnD;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAE,CAAC,CAsB/F;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,kBAAkB,GAAG,oBAAoB,GAAG,IAAI,CAwChF"}