@lark.js/mvc 0.0.14 → 0.0.15

package/dist/runtime.amd.js

@@ -0,0 +1,94 @@
+define('lark-mvc/runtime', ['exports'], (function (exports) { 'use strict';
+
+    /**
+     * Lark framework constants.
+     */
+    /** Global counter for generating unique IDs */
+    /** Internal splitter character (U+001E Record Separator, invisible, used as namespace separator).
+     * Uses String.fromCharCode to survive bundlers that strip control-char literals. */
+    const SPLITTER = String.fromCharCode(0x1e);
+    // ============================================================
+    // Encoding helpers (shared by dom.ts, runtime.ts, updater.ts)
+    // ============================================================
+    const HTML_ENT_MAP = {
+        "&": "amp",
+        "<": "lt",
+        ">": "gt",
+        '"': "#34",
+        "'": "#39",
+        "`": "#96",
+    };
+    const HTML_ENT_REGEXP = /[&<>"'`]/g;
+    /** Null-safe String conversion */
+    function strSafe$1(v) {
+        return String(v == null ? "" : v);
+    }
+    /** HTML entity encoding for safe output */
+    function encodeHTML(v) {
+        return String(v == null ? "" : v).replace(HTML_ENT_REGEXP, (m) => "&" + HTML_ENT_MAP[m] + ";");
+    }
+    const URI_ENT_MAP = {
+        "!": "%21",
+        "'": "%27",
+        "(": "%28",
+        ")": "%29",
+        "*": "%2A",
+    };
+    const URI_ENT_REGEXP = /[!')(*]/g;
+    /** URI-encode with extra character encoding */
+    function encodeURIExtra(v) {
+        return encodeURIComponent(strSafe$1(v)).replace(URI_ENT_REGEXP, (m) => URI_ENT_MAP[m]);
+    }
+    const QUOTE_ENT_REGEXP = /['"\\]/g;
+    /** Quote-encode for attribute values */
+    function encodeQuote(v) {
+        return strSafe$1(v).replace(QUOTE_ENT_REGEXP, "\\$&");
+    }
+    /**
+     * Template reference function for creating stable keys for objects.
+     * Stores objects in refData with SPLITTER-prefixed keys.
+     */
+    function refFn(ref, value, key) {
+        const counter = ref[SPLITTER];
+        for (let i = counter; --i;) {
+            key = SPLITTER + i;
+            if (ref[key] === value)
+                return key;
+        }
+        key = SPLITTER + ref[SPLITTER]++;
+        ref[key] = value;
+        return key;
+    }
+    // export function isCjs(): boolean {
+    //   return typeof module !== "undefined" && typeof module.exports !== "undefined";
+    // }
+
+    /**
+     * Template runtime helpers.
+     *
+     * Compiled templates import these helpers from `@lark.js/mvc/runtime` instead
+     * of inlining the implementations. That keeps each compiled `.html` module
+     * small — no more ~400 bytes of duplicated helper code per template.
+     *
+     * The helpers below are aliased to `$strSafe / $encHtml / $encUri / $encQuote /
+     * $refFn` inside the IIFE that the compiler produces — see `compiler.ts`.
+     *
+     * Canonical implementations live in `./common` so that dom.ts, runtime.ts,
+     * and updater.ts all share a single copy.
+     */
+    /** Null-safe `String(value)` — `null`/`undefined` become `""`. */
+    const strSafe = strSafe$1;
+    /** HTML-escape a value for safe embedding in markup. */
+    const encHtml = encodeHTML;
+    /** Percent-encode a value, with extra characters escaped for stricter URIs. */
+    const encUri = encodeURIExtra;
+    /** Backslash-escape quotes and backslashes for attribute string contents. */
+    const encQuote = encodeQuote;
+
+    exports.encHtml = encHtml;
+    exports.encQuote = encQuote;
+    exports.encUri = encUri;
+    exports.refFn = refFn;
+    exports.strSafe = strSafe;
+
+}));

package/dist/runtime.cjs

@@ -1,95 +1,92 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/runtime.ts
-var runtime_exports = {};
-__export(runtime_exports, {
-  encHtml: () => encHtml,
-  encQuote: () => encQuote,
-  encUri: () => encUri,
-  refFn: () => refFn,
-  strSafe: () => strSafe2
-});
-module.exports = __toCommonJS(runtime_exports);
-
-// src/common.ts
-var SPLITTER = String.fromCharCode(30);
-var EVENT_METHOD_REGEXP = new RegExp(
-  `(?:([\\w-]+)${SPLITTER})?([^(]+)\\(([\\s\\S]*?)?\\)`
-);
-var HTML_ENT_MAP = {
-  "&": "amp",
-  "<": "lt",
-  ">": "gt",
-  '"': "#34",
-  "'": "#39",
-  "`": "#96"
+/**
+ * Lark framework constants.
+ */
+/** Global counter for generating unique IDs */
+/** Internal splitter character (U+001E Record Separator, invisible, used as namespace separator).
+ * Uses String.fromCharCode to survive bundlers that strip control-char literals. */
+const SPLITTER = String.fromCharCode(0x1e);
+// ============================================================
+// Encoding helpers (shared by dom.ts, runtime.ts, updater.ts)
+// ============================================================
+const HTML_ENT_MAP = {
+    "&": "amp",
+    "<": "lt",
+    ">": "gt",
+    '"': "#34",
+    "'": "#39",
+    "`": "#96",
 };
-var HTML_ENT_REGEXP = /[&<>"'`]/g;
-function strSafe(v) {
-  return String(v == null ? "" : v);
+const HTML_ENT_REGEXP = /[&<>"'`]/g;
+/** Null-safe String conversion */
+function strSafe$1(v) {
+    return String(v == null ? "" : v);
 }
+/** HTML entity encoding for safe output */
 function encodeHTML(v) {
-  return String(v == null ? "" : v).replace(
-    HTML_ENT_REGEXP,
-    (m) => "&" + HTML_ENT_MAP[m] + ";"
-  );
+    return String(v == null ? "" : v).replace(HTML_ENT_REGEXP, (m) => "&" + HTML_ENT_MAP[m] + ";");
 }
-var URI_ENT_MAP = {
-  "!": "%21",
-  "'": "%27",
-  "(": "%28",
-  ")": "%29",
-  "*": "%2A"
+const URI_ENT_MAP = {
+    "!": "%21",
+    "'": "%27",
+    "(": "%28",
+    ")": "%29",
+    "*": "%2A",
 };
-var URI_ENT_REGEXP = /[!')(*]/g;
+const URI_ENT_REGEXP = /[!')(*]/g;
+/** URI-encode with extra character encoding */
 function encodeURIExtra(v) {
-  return encodeURIComponent(strSafe(v)).replace(
-    URI_ENT_REGEXP,
-    (m) => URI_ENT_MAP[m]
-  );
+    return encodeURIComponent(strSafe$1(v)).replace(URI_ENT_REGEXP, (m) => URI_ENT_MAP[m]);
 }
-var QUOTE_ENT_REGEXP = /['"\\]/g;
+const QUOTE_ENT_REGEXP = /['"\\]/g;
+/** Quote-encode for attribute values */
 function encodeQuote(v) {
-  return strSafe(v).replace(QUOTE_ENT_REGEXP, "\\$&");
+    return strSafe$1(v).replace(QUOTE_ENT_REGEXP, "\\$&");
 }
+/**
+ * Template reference function for creating stable keys for objects.
+ * Stores objects in refData with SPLITTER-prefixed keys.
+ */
 function refFn(ref, value, key) {
-  const counter = ref[SPLITTER];
-  for (let i = counter; --i; ) {
-    key = SPLITTER + i;
-    if (ref[key] === value) return key;
-  }
-  key = SPLITTER + ref[SPLITTER]++;
-  ref[key] = value;
-  return key;
+    const counter = ref[SPLITTER];
+    for (let i = counter; --i;) {
+        key = SPLITTER + i;
+        if (ref[key] === value)
+            return key;
+    }
+    key = SPLITTER + ref[SPLITTER]++;
+    ref[key] = value;
+    return key;
 }
+// export function isCjs(): boolean {
+//   return typeof module !== "undefined" && typeof module.exports !== "undefined";
+// }
+
+/**
+ * Template runtime helpers.
+ *
+ * Compiled templates import these helpers from `@lark.js/mvc/runtime` instead
+ * of inlining the implementations. That keeps each compiled `.html` module
+ * small — no more ~400 bytes of duplicated helper code per template.
+ *
+ * The helpers below are aliased to `$strSafe / $encHtml / $encUri / $encQuote /
+ * $refFn` inside the IIFE that the compiler produces — see `compiler.ts`.
+ *
+ * Canonical implementations live in `./common` so that dom.ts, runtime.ts,
+ * and updater.ts all share a single copy.
+ */
+/** Null-safe `String(value)` — `null`/`undefined` become `""`. */
+const strSafe = strSafe$1;
+/** HTML-escape a value for safe embedding in markup. */
+const encHtml = encodeHTML;
+/** Percent-encode a value, with extra characters escaped for stricter URIs. */
+const encUri = encodeURIExtra;
+/** Backslash-escape quotes and backslashes for attribute string contents. */
+const encQuote = encodeQuote;
 
-// src/runtime.ts
-var strSafe2 = strSafe;
-var encHtml = encodeHTML;
-var encUri = encodeURIExtra;
-var encQuote = encodeQuote;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  encHtml,
-  encQuote,
-  encUri,
-  refFn,
-  strSafe
-});
+exports.encHtml = encHtml;
+exports.encQuote = encQuote;
+exports.encUri = encUri;
+exports.refFn = refFn;
+exports.strSafe = strSafe;

package/dist/runtime.js

@@ -1,20 +1,86 @@
-import {
-  encodeHTML,
-  encodeQuote,
-  encodeURIExtra,
-  refFn,
-  strSafe
-} from "./chunk-66OZBBSP.js";
-
-// src/runtime.ts
-var strSafe2 = strSafe;
-var encHtml = encodeHTML;
-var encUri = encodeURIExtra;
-var encQuote = encodeQuote;
-export {
-  encHtml,
-  encQuote,
-  encUri,
-  refFn,
-  strSafe2 as strSafe
+/**
+ * Lark framework constants.
+ */
+/** Global counter for generating unique IDs */
+/** Internal splitter character (U+001E Record Separator, invisible, used as namespace separator).
+ * Uses String.fromCharCode to survive bundlers that strip control-char literals. */
+const SPLITTER = String.fromCharCode(0x1e);
+// ============================================================
+// Encoding helpers (shared by dom.ts, runtime.ts, updater.ts)
+// ============================================================
+const HTML_ENT_MAP = {
+    "&": "amp",
+    "<": "lt",
+    ">": "gt",
+    '"': "#34",
+    "'": "#39",
+    "`": "#96",
+};
+const HTML_ENT_REGEXP = /[&<>"'`]/g;
+/** Null-safe String conversion */
+function strSafe$1(v) {
+    return String(v == null ? "" : v);
+}
+/** HTML entity encoding for safe output */
+function encodeHTML(v) {
+    return String(v == null ? "" : v).replace(HTML_ENT_REGEXP, (m) => "&" + HTML_ENT_MAP[m] + ";");
+}
+const URI_ENT_MAP = {
+    "!": "%21",
+    "'": "%27",
+    "(": "%28",
+    ")": "%29",
+    "*": "%2A",
 };
+const URI_ENT_REGEXP = /[!')(*]/g;
+/** URI-encode with extra character encoding */
+function encodeURIExtra(v) {
+    return encodeURIComponent(strSafe$1(v)).replace(URI_ENT_REGEXP, (m) => URI_ENT_MAP[m]);
+}
+const QUOTE_ENT_REGEXP = /['"\\]/g;
+/** Quote-encode for attribute values */
+function encodeQuote(v) {
+    return strSafe$1(v).replace(QUOTE_ENT_REGEXP, "\\$&");
+}
+/**
+ * Template reference function for creating stable keys for objects.
+ * Stores objects in refData with SPLITTER-prefixed keys.
+ */
+function refFn(ref, value, key) {
+    const counter = ref[SPLITTER];
+    for (let i = counter; --i;) {
+        key = SPLITTER + i;
+        if (ref[key] === value)
+            return key;
+    }
+    key = SPLITTER + ref[SPLITTER]++;
+    ref[key] = value;
+    return key;
+}
+// export function isCjs(): boolean {
+//   return typeof module !== "undefined" && typeof module.exports !== "undefined";
+// }
+
+/**
+ * Template runtime helpers.
+ *
+ * Compiled templates import these helpers from `@lark.js/mvc/runtime` instead
+ * of inlining the implementations. That keeps each compiled `.html` module
+ * small — no more ~400 bytes of duplicated helper code per template.
+ *
+ * The helpers below are aliased to `$strSafe / $encHtml / $encUri / $encQuote /
+ * $refFn` inside the IIFE that the compiler produces — see `compiler.ts`.
+ *
+ * Canonical implementations live in `./common` so that dom.ts, runtime.ts,
+ * and updater.ts all share a single copy.
+ */
+/** Null-safe `String(value)` — `null`/`undefined` become `""`. */
+const strSafe = strSafe$1;
+/** HTML-escape a value for safe embedding in markup. */
+const encHtml = encodeHTML;
+/** Percent-encode a value, with extra characters escaped for stricter URIs. */
+const encUri = encodeURIExtra;
+/** Backslash-escape quotes and backslashes for attribute string contents. */
+const encQuote = encodeQuote;
+
+export { encHtml, encQuote, encUri, refFn, strSafe };

package/dist/runtime.umd.js

@@ -0,0 +1,98 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.LarkMvc = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * Lark framework constants.
+     */
+    /** Global counter for generating unique IDs */
+    /** Internal splitter character (U+001E Record Separator, invisible, used as namespace separator).
+     * Uses String.fromCharCode to survive bundlers that strip control-char literals. */
+    const SPLITTER = String.fromCharCode(0x1e);
+    // ============================================================
+    // Encoding helpers (shared by dom.ts, runtime.ts, updater.ts)
+    // ============================================================
+    const HTML_ENT_MAP = {
+        "&": "amp",
+        "<": "lt",
+        ">": "gt",
+        '"': "#34",
+        "'": "#39",
+        "`": "#96",
+    };
+    const HTML_ENT_REGEXP = /[&<>"'`]/g;
+    /** Null-safe String conversion */
+    function strSafe$1(v) {
+        return String(v == null ? "" : v);
+    }
+    /** HTML entity encoding for safe output */
+    function encodeHTML(v) {
+        return String(v == null ? "" : v).replace(HTML_ENT_REGEXP, (m) => "&" + HTML_ENT_MAP[m] + ";");
+    }
+    const URI_ENT_MAP = {
+        "!": "%21",
+        "'": "%27",
+        "(": "%28",
+        ")": "%29",
+        "*": "%2A",
+    };
+    const URI_ENT_REGEXP = /[!')(*]/g;
+    /** URI-encode with extra character encoding */
+    function encodeURIExtra(v) {
+        return encodeURIComponent(strSafe$1(v)).replace(URI_ENT_REGEXP, (m) => URI_ENT_MAP[m]);
+    }
+    const QUOTE_ENT_REGEXP = /['"\\]/g;
+    /** Quote-encode for attribute values */
+    function encodeQuote(v) {
+        return strSafe$1(v).replace(QUOTE_ENT_REGEXP, "\\$&");
+    }
+    /**
+     * Template reference function for creating stable keys for objects.
+     * Stores objects in refData with SPLITTER-prefixed keys.
+     */
+    function refFn(ref, value, key) {
+        const counter = ref[SPLITTER];
+        for (let i = counter; --i;) {
+            key = SPLITTER + i;
+            if (ref[key] === value)
+                return key;
+        }
+        key = SPLITTER + ref[SPLITTER]++;
+        ref[key] = value;
+        return key;
+    }
+    // export function isCjs(): boolean {
+    //   return typeof module !== "undefined" && typeof module.exports !== "undefined";
+    // }
+
+    /**
+     * Template runtime helpers.
+     *
+     * Compiled templates import these helpers from `@lark.js/mvc/runtime` instead
+     * of inlining the implementations. That keeps each compiled `.html` module
+     * small — no more ~400 bytes of duplicated helper code per template.
+     *
+     * The helpers below are aliased to `$strSafe / $encHtml / $encUri / $encQuote /
+     * $refFn` inside the IIFE that the compiler produces — see `compiler.ts`.
+     *
+     * Canonical implementations live in `./common` so that dom.ts, runtime.ts,
+     * and updater.ts all share a single copy.
+     */
+    /** Null-safe `String(value)` — `null`/`undefined` become `""`. */
+    const strSafe = strSafe$1;
+    /** HTML-escape a value for safe embedding in markup. */
+    const encHtml = encodeHTML;
+    /** Percent-encode a value, with extra characters escaped for stricter URIs. */
+    const encUri = encodeURIExtra;
+    /** Backslash-escape quotes and backslashes for attribute string contents. */
+    const encQuote = encodeQuote;
+
+    exports.encHtml = encHtml;
+    exports.encQuote = encQuote;
+    exports.encUri = encUri;
+    exports.refFn = refFn;
+    exports.strSafe = strSafe;
+
+}));

package/dist/service.d.ts

@@ -0,0 +1,173 @@
+import { Cache } from "./cache";
+import { EventEmitter } from "./event-emitter";
+import type { AnyFunc, ServiceMetaEntry, ServiceCacheInfo, PendingCacheEntry, PayloadInterface, EventEmitterInterface } from "./types";
+/**
+ * Payload wraps API response data with convenient access methods.
+ */
+export declare class Payload implements PayloadInterface {
+    /** Payload data */
+    data: Record<string, unknown>;
+    /** Internal cache info */
+    cacheInfo?: ServiceCacheInfo;
+    constructor(data?: Record<string, unknown>);
+    /** Get a value from payload data */
+    get<T = unknown>(key: string): T;
+    /** Set a value in payload data */
+    set(keyOrData: string | Record<string, unknown> | ServiceMetaEntry, value?: unknown): PayloadInterface;
+}
+/**
+ * Minimal interface describing what serviceSend actually uses
+ * from a service instance. This avoids coupling to the full
+ * ServiceInterface which mixes instance and static methods.
+ */
+interface ServiceSendTarget {
+    destroyed: number;
+    busy: number;
+    internals: {
+        metaList: Record<string, ServiceMetaEntry>;
+        payloadCache: Cache<Payload>;
+        pendingCacheKeys: Record<string, PendingCacheEntry>;
+        syncFn: (payload: Payload, callback: () => void) => void;
+        staticEmitter: EventEmitter;
+    };
+    type: {
+        get(attrs: Record<string, unknown>, createNew?: boolean): {
+            entity: Payload;
+            needsUpdate: boolean;
+        };
+    };
+    enqueue(callback: AnyFunc): unknown;
+}
+/**
+ * Service: API request management with caching, deduplication, and queue.
+ *
+ * - Service.extend(syncFn, cacheMax?, cacheBuffer?): creates subclass with sync function
+ * - Service.add(attrs): registers API endpoint metadata
+ * - new Service().all(attrs, done): fetch all, use cache when available
+ * - new Service().one(attrs, done): fetch all, callback on each completion
+ * - new Service().save(attrs, done): fetch all, skip cache (always request)
+ * - enqueue/dequeue: task queue for sequential async operations
+ * - destroy: cancel pending requests
+ *
+ * Per-type state (metaList, payloadCache, pendingCacheKeys, syncFn, staticEmitter)
+ * is stored as static class properties. When extend() creates a subclass,
+ * each subclass gets its own copies of these static properties, ensuring
+ * isolation between different Service types.
+ */
+export declare class Service {
+    /** Service instance ID */
+    id: string;
+    /** Whether service is busy (1 = busy) */
+    busy: number;
+    /** Whether service is destroyed (1 = destroyed) */
+    destroyed: number;
+    /** Task queue for sequential operations */
+    taskQueue: AnyFunc[];
+    /** Previous dequeue arguments */
+    prevArgs: unknown[];
+    /** Instance event emitter */
+    private _emitter;
+    constructor();
+    /** Instance event emitter (public accessor) */
+    get emitter(): EventEmitterInterface;
+    /**
+     * Get internals object for serviceSend compatibility.
+     * References per-type static state from the current class.
+     */
+    get internals(): ServiceSendTarget["internals"];
+    /**
+     * Get type reference (the constructor) for serviceSend compatibility.
+     * Static methods like get/create are accessible via the constructor.
+     */
+    get type(): ServiceSendTarget["type"];
+    /**
+     * Fetch all endpoints, callback when all complete.
+     * Uses cache when available.
+     */
+    all(attrs: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): this;
+    /**
+     * Fetch all endpoints, callback on each completion.
+     */
+    one(attrs: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): this;
+    /**
+     * Fetch all endpoints, skip cache (always request).
+     */
+    save(attrs: string | Record<string, unknown> | (string | Record<string, unknown>)[], done: AnyFunc): this;
+    /**
+     * Enqueue a task for sequential execution.
+     */
+    enqueue(callback: AnyFunc): this;
+    /**
+     * Dequeue and execute the next task in queue.
+     */
+    dequeue(...args: unknown[]): void;
+    /**
+     * Destroy the service instance.
+     * After destruction, no new requests can be sent.
+     */
+    destroy(): void;
+    on(event: string, handler: AnyFunc): this;
+    off(event: string, handler?: AnyFunc): this;
+    fire(event: string, data?: Record<string, unknown>): this;
+    /** Per-type metadata registry */
+    static _metaList: Record<string, ServiceMetaEntry>;
+    /** Per-type payload cache (LFU with frequency eviction) */
+    static _payloadCache: Cache<Payload>;
+    /** Per-type pending cache keys for deduplication */
+    static _pendingCacheKeys: Record<string, PendingCacheEntry>;
+    /** Per-type sync function */
+    static _syncFn: (payload: Payload, callback: () => void) => void;
+    /** Per-type static event emitter */
+    static _staticEmitter: EventEmitter<unknown>;
+    /** Per-type cache max size */
+    static _cacheMax: number;
+    /** Per-type cache buffer size */
+    static _cacheBuffer: number;
+    /**
+     * Register API endpoint metadata.
+     */
+    static add(attrs: ServiceMetaEntry | ServiceMetaEntry[]): void;
+    /**
+     * Get metadata for an API endpoint.
+     */
+    static meta(attrs: string | Record<string, unknown>): ServiceMetaEntry;
+    /**
+     * Create a Payload for an API request.
+     */
+    static create(attrs: Record<string, unknown>): Payload;
+    /**
+     * Get or create a Payload for an API request.
+     */
+    static get(attrs: Record<string, unknown>, createNew?: boolean): {
+        entity: Payload;
+        needsUpdate: boolean;
+    };
+    /**
+     * Get cached Payload if available and not expired.
+     */
+    static cached(attrs: Record<string, unknown>): Payload | undefined;
+    /**
+     * Clear cached payloads by endpoint name.
+     */
+    static clear(names: string | string[]): void;
+    static on(event: string, handler: AnyFunc): void;
+    static off(event: string, handler?: AnyFunc): void;
+    static fire(event: string, data?: Record<string, unknown>): void;
+    /**
+     * Create a new Service subclass with a custom sync function.
+     *
+     * Each subclass gets its OWN copies of every per-type static field
+     * (`_metaList`, `_payloadCache`, `_pendingCacheKeys`, `_syncFn`,
+     * `_staticEmitter`, `_cacheMax`, `_cacheBuffer`) via `static override`.
+     * This is intentional: it ensures that endpoint metadata, cache state,
+     * in-flight dedup keys, and event subscribers are fully isolated between
+     * different Service types, even when one extends another.
+     *
+     * **Do not refactor these `static override` declarations away** — sharing
+     * them through prototype inheritance would let endpoints registered on one
+     * subclass leak into another, and the LFU cache evictions of one type
+     * would race with those of another.
+     */
+    static extend(this: typeof Service, newSyncFn: (payload: Payload, callback: () => void) => void, newCacheMax?: number, newCacheBuffer?: number): typeof Service;
+}
+export {};

package/dist/state.d.ts

@@ -0,0 +1,8 @@
+import type { StateInterface } from "./types";
+/** Mark framework as booted (called from Framework.boot) */
+export declare function markBooted(): void;
+/**
+ * Observable in-memory data object.
+ * Provides get/set/digest/diff/clean methods for cross-view data sharing.
+ */
+export declare const State: StateInterface;