@cldmv/slothlet 3.3.0 → 3.3.2

package/types/dist/lib/runtime/runtime-livebindings.d.mts

@@ -1,38 +1,3 @@
-/**
- * Live binding to the current API (self-reference)
- * @type {Proxy}
- * @public
- *
- * @description
- * A proxy that provides direct access to the current instance's API.
- * In live mode, this directly references the active instance without AsyncLocalStorage.
- *
- * @example
- * import { self } from "@cldmv/slothlet/runtime/live";
- *
- * export function callOtherFunction() {
- *   return self.otherFunction();
- * }
- */
-export const self: ProxyConstructor;
-/**
- * User-provided context object
- * @type {Proxy}
- * @public
- *
- * @description
- * A proxy that provides access to user-provided context data.
- * In live mode, this directly accesses the current instance's context.
- *
- * @example
- * import { context } from "@cldmv/slothlet/runtime/live";
- *
- * export function getUserInfo() {
- *   return {
- *     userId: context.userId,
- *     userName: context.userName
- *   };
- * }
- */
-export const context: ProxyConstructor;
+export const context: {};
+export const self: {};
 //# sourceMappingURL=runtime-livebindings.d.mts.map

package/types/dist/lib/runtime/runtime-livebindings.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-livebindings.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime-livebindings.mjs"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;GAeG;AACH,oCAgCE;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,uCAkCE"}
+{"version":3,"file":"runtime-livebindings.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime-livebindings.mjs"],"names":[],"mappings":"AAAwuB,yBAA2tB;AAAt1C,sBAA2nB"}

package/types/dist/lib/runtime/runtime.d.mts

@@ -1,40 +1,4 @@
-/**
- * Live binding to the current API instance. Resolves to the running Slothlet proxy,
- * giving API modules access to all other API methods without import cycles.
- *
- * @memberof module:@cldmv/slothlet/runtime
- * @type {object}
- * @example
- * import { self } from "@cldmv/slothlet/runtime";
- * // Inside an API function:
- * const result = await self.math.add(1, 2);
- */
-export const self: object;
-/**
- * The current ambient context object. Seeded at instance startup via `config.context` and
- * persists for the lifetime of the instance. `api.slothlet.context.run()` and `.scope()` can
- * temporarily override it for the duration of a single call, after which the previous context
- * is restored. Readable and writable.
- *
- * @memberof module:@cldmv/slothlet/runtime
- * @type {object}
- * @example
- * import { context } from "@cldmv/slothlet/runtime";
- * // Read the ambient context set via config.context or written by a previous call:
- * const userId = context.userId;
- * // context.run() overrides it only for the duration of that one call:
- * await api.slothlet.context.run({ userId: 42 }, myFn);
- */
-export const context: object;
-/**
- * Current Slothlet instance identifier. Unique per `slothlet()` call; useful when
- * multiple Slothlet instances coexist and you need to identify which one is active.
- *
- * @memberof module:@cldmv/slothlet/runtime
- * @type {string}
- * @example
- * import { instanceID } from "@cldmv/slothlet/runtime";
- * console.log(instanceID); // e.g. "slothlet-1"
- */
-export const instanceID: string;
+export const context: {};
+export const instanceID: {};
+export const self: {};
 //# sourceMappingURL=runtime.d.mts.map

package/types/dist/lib/runtime/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime.mjs"],"names":[],"mappings":"AAkEA;;;;;;;;;;GAUG;AACH,mBANU,MAAM,CAgCd;AAEF;;;;;;;;;;;;;;GAcG;AACH,sBARU,MAAM,CAiCd;AAEF;;;;;;;;;GASG;AACH,yBALU,MAAM,CAiBd"}
+{"version":3,"file":"runtime.d.mts","sourceRoot":"","sources":["../../../../dist/lib/runtime/runtime.mjs"],"names":[],"mappings":"AAA02B,yBAA4e;AAAA,4BAAoP;AAA7pC,sBAA6b"}

package/types/dist/slothlet.d.mts

@@ -1,250 +1,4 @@
-/**
- * Create a new Slothlet instance and load an API from a directory.
- * This is the sole public entry point for slothlet. Each call produces an independent
- * API instance with its own component graph, context store, and lifecycle.
- * @alias module:@cldmv/slothlet
- * @async
- * @param {SlothletOptions} config - Configuration options
- * @returns {Promise<SlothletAPI>} Fully loaded, proxy-based API object
- * @public
- * @example
- * // Minimal usage
- * const api = await slothlet({ dir: "./api" });
- * const result = await api.math.add(2, 3);
- * await api.slothlet.shutdown();
- *
- * @example
- * // Lazy mode with background materialization
- * const api = await slothlet({
- *   dir: "./api",
- *   mode: "lazy",
- *   backgroundMaterialize: true
- * });
- *
- * @example
- * // With hooks
- * const api = await slothlet({ dir: "./api", hook: true });
- * api.slothlet.hook.on("before", "**", (endpoint, args) => { /* ... *\/ });
- *
- * @example
- * // Hot-reload a module at runtime
- * await api.slothlet.api.reload("./api/math.mjs");
- *
- * @example
- * // Strict collision control
- * const api = await slothlet({
- *   dir: "./api",
- *   api: { collision: { initial: "merge", api: "error" } }
- * });
- */
-export function slothlet(config: SlothletOptions): Promise<SlothletAPI>;
-export default slothlet;
-/**
- * Configuration options passed to `slothlet()`.
- */
-export type SlothletOptions = {
-    /**
-     * - Directory to scan for API modules. Relative paths are resolved from the calling file.
-     */
-    dir: string;
-    /**
-     * - Loading strategy.
-     * - `"eager"` — all modules are loaded immediately at startup (default).
-     * - `"lazy"` — modules are loaded on first access via a Proxy.
-     * Also accepted: `"immediate"` / `"preload"` (eager aliases); `"deferred"` / `"proxy"` (lazy aliases).
-     */
-    mode?: "eager" | "lazy";
-    /**
-     * - Context propagation runtime.
-     * - `"async"` — AsyncLocalStorage (Node.js built-in, recommended for production).
-     * - `"live"` — Experimental live bindings.
-     * Also accepted: `"asynclocalstorage"` / `"als"` / `"node"` as aliases for `"async"`.
-     */
-    runtime?: "async" | "live";
-    /**
-     * - Directory traversal depth. `Infinity` scans all subdirectories (default). `0` scans only the root.
-     */
-    apiDepth?: number;
-    /**
-     * - Object merged into the per-request context accessible inside API functions via `import { context } from "@cldmv/slothlet/runtime"`.
-     */
-    context?: object | null;
-    /**
-     * - Object whose properties are merged directly onto the root API and also available as `api.slothlet.reference`.
-     */
-    reference?: object | null;
-    /**
-     * - Controls how per-request scope data is merged. `"shallow"` merges top-level keys; `"deep"` recurses into nested objects.
-     */
-    scope?: {
-        merge: "shallow" | "deep";
-    };
-    /**
-     * - API build and mutation settings.
-     */
-    api?: {
-        collision?: string | {
-            initial: string;
-            api: string;
-        };
-        mutations?: object;
-    };
-    /**
-     * - Hook system configuration.
-     * - `false` — disabled (default).
-     * - `true` — enabled, all endpoints.
-     * - `string` — enabled with a default glob pattern.
-     * - `object` — full control: `{ enabled: boolean, pattern?: string, suppressErrors?: boolean }`.
-     */
-    hook?: boolean | string | object;
-    /**
-     * - Enable verbose internal logging. `true` enables all categories.
-     * Pass an object with sub-keys `builder`, `api`, `index`, `modes`, `wrapper`, `ownership`, `context` to target specific subsystems.
-     */
-    debug?: boolean | object;
-    /**
-     * - Suppress all console output from slothlet (warnings, deprecations). Does not affect `debug`.
-     */
-    silent?: boolean;
-    /**
-     * - Enable the `api.slothlet.diag.*` introspection namespace. Intended for testing; do not enable in production.
-     */
-    diagnostics?: boolean;
-    /**
-     * - Enable internal tracking. Pass `true` or `{ materialization: true }` to track lazy-mode materialization progress.
-     */
-    tracking?: boolean | object;
-    /**
-     * - When `mode: "lazy"`, immediately begins materializing all paths in the background after init.
-     */
-    backgroundMaterialize?: boolean;
-    /**
-     * - Internationalization settings (dev-facing, process-global).
-     * `{ language: string }` — selects the locale for framework messages (e.g. `"en-us"`, `"fr-fr"`, `"ja-jp"`).
-     */
-    i18n?: object;
-    /**
-     * - Environment variable snapshot configuration.
-     * Pass `{ include: ["KEY"] }` to capture only the listed variable names in `api.slothlet.env`.
-     * Omit (or pass `undefined`) to capture a full frozen snapshot of `process.env`.
-     * Non-string entries in `include` are silently ignored; an all-non-string array falls back to the full snapshot.
-     */
-    env?: {
-        include?: string[];
-    };
-    /**
-     * - TypeScript support.
-     * - `false` — disabled (default).
-     * - `true` or `"fast"` — esbuild transpilation, no type checking.
-     * - `"strict"` — tsc compilation with type checking and `.d.ts` generation.
-     * See [TYPESCRIPT.md](docs/TYPESCRIPT.md) for the full configuration reference.
-     */
-    typescript?: boolean | "fast" | "strict" | object;
-    /**
-     * - Version routing discriminator for versioned API paths.
-     * - **string** (e.g. `"version"`) — at dispatch time, reads that key from the calling module's version metadata to select a version tag.
-     * - **function** — called as `(allVersions, caller) => versionTag | null`; return a registered version tag to force routing, or `null`/`undefined` to fall through to the automatic default.
-     * - **omitted / `undefined`** — behaves identically to `"version"`.
-     * Only relevant when modules are registered via `api.slothlet.api.add()` with a `versionConfig` argument.
-     */
-    versionDispatcher?: string | Function | null;
-};
-/**
- * Bound API object returned by `slothlet()`.
- * The root contains all loaded module exports plus the reserved `slothlet` namespace.
- */
-export type SlothletAPI = {
-    /**
-     * - Like `shutdown()` but additionally invokes registered destroy hooks before teardown. %%sig: (): void%% %%example: // ESM usage via slothlet API|import slothlet from "@cldmv/slothlet";|const api = await slothlet({ dir: './api' });|await api.destroy();%% %%example: // ESM usage via slothlet API (inside async function)|async function example() {|  const { default: slothlet } = await import("@cldmv/slothlet");|  const api = await slothlet({ dir: './api' });|  await api.destroy();|}%% %%example: // CJS usage via slothlet API (top-level)|let slothlet;|(async () => {|  ({ slothlet } = await import("@cldmv/slothlet"));|  const api = await slothlet({ dir: './api' });|  await api.destroy();|})();%% %%example: // CJS usage via slothlet API (inside async function)|const slothlet = require("@cldmv/slothlet");|const api = await slothlet({ dir: './api' });|await api.destroy();%%
-     */
-    destroy: () => void;
-    /**
-     * - Convenience alias for `slothlet.shutdown()`. Shuts down the instance and invokes any user-provided shutdown hook first. %%sig: (): void%% %%example: // ESM usage via slothlet API|import slothlet from "@cldmv/slothlet";|const api = await slothlet({ dir: './api' });|await api.shutdown();%% %%example: // ESM usage via slothlet API (inside async function)|async function example() {|  const { default: slothlet } = await import("@cldmv/slothlet");|  const api = await slothlet({ dir: './api' });|  await api.shutdown();|}%% %%example: // CJS usage via slothlet API (top-level)|let slothlet;|(async () => {|  ({ slothlet } = await import("@cldmv/slothlet"));|  const api = await slothlet({ dir: './api' });|  await api.shutdown();|})();%% %%example: // CJS usage via slothlet API (inside async function)|const slothlet = require("@cldmv/slothlet");|const api = await slothlet({ dir: './api' });|await api.shutdown();%%
-     */
-    shutdown: () => void;
-    /**
-     * - Built-in control namespace. All framework internals live here to avoid collisions with loaded modules.
-     */
-    slothlet: {
-        env: Readonly<Record<string, string | undefined>>;
-        api: {
-            add: Function;
-            reload: Function;
-            remove: Function;
-        };
-        context: {
-            get: Function;
-            inspect: () => any;
-            run: Function;
-            scope: Function;
-            set: Function;
-        };
-        diag?: {
-            caches?: {
-                get?: () => any;
-                getAllModuleIDs?: () => string[];
-                has?: Function;
-            };
-            context?: object;
-            describe?: Function;
-            getAPI?: () => any;
-            getOwnership?: () => any;
-            hook?: object;
-            inspect?: () => any;
-            owner?: {
-                get?: Function;
-            };
-            reference?: object;
-            SlothletWarning?: () => SlothletWarning;
-        };
-        hook: {
-            clear: Function;
-            disable: Function;
-            enable: Function;
-            list: Function;
-            off: Function;
-            on: Function;
-            remove: Function;
-        };
-        lifecycle: {
-            off: Function;
-            on: Function;
-        };
-        materialize: {
-            get: () => any;
-            materialized: boolean;
-            wait: () => Promise<void>;
-        };
-        metadata: {
-            caller: () => any | null;
-            get: Function;
-            remove: Function;
-            removeFor: Function;
-            self: () => any | null;
-            set: Function;
-            setFor: Function;
-            setGlobal: Function;
-        };
-        owner: {
-            get: Function;
-        };
-        ownership: {
-            get: Function;
-            unregister: Function;
-        };
-        versioning: {
-            list: Function;
-            setDefault: Function;
-            unregister: Function;
-            getVersionMetadata: Function;
-            setVersionMetadata: Function;
-        };
-        reference?: object;
-        reload: Function;
-        run: Function;
-        scope: Function;
-        shutdown: () => Promise<void>;
-    };
-};
-import { SlothletWarning } from "@cldmv/slothlet/errors";
+declare function stdin_default(config: any): Promise<{}>;
+export function slothlet(config: any): Promise<{}>;
+export { stdin_default as default };
 //# sourceMappingURL=slothlet.d.mts.map

package/types/dist/slothlet.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"slothlet.d.mts","sourceRoot":"","sources":["../../dist/slothlet.mjs"],"names":[],"mappings":"AAq/BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,iCAjCW,eAAe,GACb,OAAO,CAAC,WAAW,CAAC,CAsChC;;;;;;;;;SAWa,MAAM;;;;;;;WACN,OAAO,GAAC,MAAM;;;;;;;cAId,OAAO,GAAC,MAAM;;;;eAId,MAAM;;;;cACN,MAAM,GAAC,IAAI;;;;gBACX,MAAM,GAAC,IAAI;;;;YACX;QAAC,KAAK,EAAE,SAAS,GAAC,MAAM,CAAA;KAAC;;;;UAEpC;QAAuD,SAAS,GAArD,MAAM,GAAC;YAAC,OAAO,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAC;QAGxB,SAAS,GAAtB,MAAM;KAEjB;;;;;;;;WAAW,OAAO,GAAC,MAAM,GAAC,MAAM;;;;;YAKrB,OAAO,GAAC,MAAM;;;;aAEd,OAAO;;;;kBACP,OAAO;;;;eACP,OAAO,GAAC,MAAM;;;;4BACd,OAAO;;;;;WACP,MAAM;;;;;;;UAMjB;QAA0B,OAAO,GAAtB,MAAM,EAAE;KACnB;;;;;;;;iBAAW,OAAO,GAAC,MAAM,GAAC,QAAQ,GAAC,MAAM;;;;;;;;wBAK9B,MAAM,cAAU,IAAI;;;;;;;;;;aAWpB,MAAY,IAAI;;;;cAChB,MAAY,IAAI;;;;cAE3B;QAAgE,GAAG,EAAxD,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAC,SAAS,CAAC,CAAC;QACzB,GAAG,EAC/B;YAAkC,GAAG;YACH,MAAM;YACN,MAAM;SACxC;QAA4B,OAAO,EACnC;YAAsC,GAAG;YACO,OAAO,EAA5C,SAAkB;YACS,GAAG;YACH,KAAK;YACL,GAAG;SACzC;QAA6B,IAAI,GACjC;YAAkC,MAAM,GACxC;gBAAqD,GAAG,GAA7C,SAAkB;gBAC0B,eAAe,GAA3D,MAAY,MAAM,EAAE;gBACY,GAAG;aAC9C;YAAkC,OAAO,GAA9B,MAAM;YACmB,QAAQ;YACE,MAAM,GAAzC,SAAkB;YACiB,YAAY,GAA/C,SAAkB;YACK,IAAI,GAA3B,MAAM;YAC6B,OAAO,GAA1C,SAAkB;YACK,KAAK,GACvC;gBAA0C,GAAG;aAC7C;YAAkC,SAAS,GAAhC,MAAM;YACsC,eAAe,GAA3D,MAAY,eAAe;SACtC;QAA4B,IAAI,EAChC;YAAmC,KAAK;YACL,OAAO;YACP,MAAM;YACN,IAAI;YACJ,GAAG;YACH,EAAE;YACF,MAAM;SACzC;QAA4B,SAAS,EACrC;YAAwC,GAAG;YACH,EAAE;SAC1C;QAA4B,WAAW,EACvC;YAAoD,GAAG,EAA5C,SAAkB;YACY,YAAY,EAA1C,OAAO;YAC0C,IAAI,EAArD,MAAY,OAAO,CAAE,IAAI,CAAC;SACrC;QAA4B,QAAQ,EACpC;YAAsD,MAAM,EAAjD,MAAY,MAAO,IAAI;YACK,GAAG;YACH,MAAM;YACN,SAAS;YACM,IAAI,EAA/C,MAAY,MAAO,IAAI;YACK,GAAG;YACH,MAAM;YACN,SAAS;SAChD;QAA4B,KAAK,EACjC;YAAoC,GAAG;SACvC;QAA4B,SAAS,EACrC;YAAwC,GAAG;YACH,UAAU;SAClD;QAA4B,UAAU,EACtC;YAAyC,IAAI;YACJ,UAAU;YACV,UAAU;YACV,kBAAkB;YAClB,kBAAkB;SAC3D;QAA6B,SAAS,GAA3B,MAAM;QACa,MAAM;QACN,GAAG;QACH,KAAK;QACa,QAAQ,EAA7C,MAAY,OAAO,CAAE,IAAI,CAAC;KACvC;;gCAhlC6D,wBAAwB"}
+{"version":3,"file":"slothlet.d.mts","sourceRoot":"","sources":["../../dist/slothlet.mjs"],"names":[],"mappings":"AAAwga,yDAA6G;AAA7G,mDAA6G"}

package/types/index.d.mts

@@ -1,19 +1,39 @@
 /**
- * TypeScript declarations for @cldmv/slothlet index
- * 
- * This file is auto-generated by tools/build-exports.mjs
- * Run: npm run build:exports to regenerate
+ * Creates a slothlet API instance with live-binding context and AsyncLocalStorage support.
+ * Automatically wraps all API functions with context isolation for multi-instance support.
+ * @public
+ * @async
+ *
+ * @param {object} [options={}] - Configuration options for the slothlet instance
+ * @param {string} [options.dir="api"] - Directory to load API modules from
+ * @param {boolean} [options.lazy=false] - Use lazy loading (true) or eager loading (false) - legacy option
+ * @param {string} [options.mode] - Loading mode ("lazy", "eager") or execution mode ("singleton", "vm", "worker", "fork") - takes precedence over lazy option
+ * @param {string} [options.engine="singleton"] - Execution mode (singleton, vm, worker, fork)
+ * @param {number} [options.apiDepth=Infinity] - Maximum directory depth to scan
+ * @param {boolean} [options.debug=false] - Enable debug logging
+ * @param {string} [options.api_mode="auto"] - API structure mode (auto, function, object)
+ * @param {boolean} [options.allowApiOverwrite=true] - Allow addApi to overwrite existing API endpoints
+ * @param {object} [options.context={}] - Context data for live bindings
+ * @param {object} [options.reference={}] - Reference objects to merge into API root
+ * @returns {Promise<import("./src/slothlet.mjs").SlothletAPI>} The bound API object with management methods
+ *
+ * @example // ESM
+ * import slothlet from "@cldmv/slothlet";
+ * const api = await slothlet({ dir: './api', lazy: true });
+ * const result = await api.math.add(2, 3); // 5
+ *
  */
-
-// Re-export all types from the main slothlet module
-export type * from "./dist/slothlet.d.mts";
-// If you want runtime exports, use the implementation file instead:
-export * from "./dist/slothlet.mts";
-
-// Auto-generated named export declarations (these override the re-export above)
-export const async: any;
-
-// Main slothlet export
-declare const slothlet: any;
-export default slothlet;
+export default function slothlet(options?: {
+    dir?: string | undefined;
+    lazy?: boolean | undefined;
+    mode?: string | undefined;
+    engine?: string | undefined;
+    apiDepth?: number | undefined;
+    debug?: boolean | undefined;
+    api_mode?: string | undefined;
+    allowApiOverwrite?: boolean | undefined;
+    context?: object | undefined;
+    reference?: object | undefined;
+}): Promise<import("./src/slothlet.mjs").SlothletAPI>;
 export { slothlet };
+//# sourceMappingURL=index.d.mts.map

package/types/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../index.mjs"],"names":[],"mappings":"AA+FA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,2CAlBG;IAAyB,GAAG;IACF,IAAI;IACL,IAAI;IACJ,MAAM;IACN,QAAQ;IACP,KAAK;IACN,QAAQ;IACP,iBAAiB;IAClB,OAAO;IACP,SAAS;CAClC,GAAU,OAAO,CAAC,OAAO,oBAAoB,EAAE,WAAW,CAAC,CAkB7D"}