actly 1.1.5 → 1.2.0

package/dist/core/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../src/core/health.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAExD,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,MAAM,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;IAChE,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAOD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAErD;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAEvD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/E;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAElD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,YAAY,CAU1E"}

package/dist/core/health.js

@@ -0,0 +1,28 @@
+let globalInflight = 0;
+let startTime = Date.now();
+let globalLastError;
+let globalLastSuccessAt;
+export function registerInflight(_scope) {
+    globalInflight++;
+}
+export function unregisterInflight(_scope) {
+    globalInflight = Math.max(0, globalInflight - 1);
+}
+export function recordError(_scope, code, message) {
+    globalLastError = { code, message, timestamp: Date.now() };
+}
+export function recordSuccess(_scope) {
+    globalLastSuccessAt = Date.now();
+}
+export function createHealthCheck(store) {
+    return () => {
+        return {
+            storeSize: store.size(),
+            pendingInflight: globalInflight,
+            uptimeMs: Date.now() - startTime,
+            lastError: globalLastError,
+            lastSuccessAt: globalLastSuccessAt,
+        };
+    };
+}
+//# sourceMappingURL=health.js.map

package/dist/core/health.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.js","sourceRoot":"","sources":["../../src/core/health.ts"],"names":[],"mappings":"AAUA,IAAI,cAAc,GAAG,CAAC,CAAA;AACtB,IAAI,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;AAC1B,IAAI,eAAiF,CAAA;AACrF,IAAI,mBAAuC,CAAA;AAE3C,MAAM,UAAU,gBAAgB,CAAC,MAAc;IAC7C,cAAc,EAAE,CAAA;AAClB,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,MAAc;IAC/C,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,cAAc,GAAG,CAAC,CAAC,CAAA;AAClD,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,MAAc,EAAE,IAAY,EAAE,OAAe;IACvE,eAAe,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAA;AAC5D,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,MAAc;IAC1C,mBAAmB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;AAClC,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,KAAoB;IACpD,OAAO,GAAG,EAAE;QACV,OAAO;YACL,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE;YACvB,eAAe,EAAE,cAAc;YAC/B,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;YAChC,SAAS,EAAE,eAAe;YAC1B,aAAa,EAAE,mBAAmB;SACnC,CAAA;IACH,CAAC,CAAA;AACH,CAAC"}

package/dist/core/shutdown.cjs

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDrainable = registerDrainable;
+exports.unregisterDrainable = unregisterDrainable;
+exports.drain = drain;
+const drainStates = new Map();
+function getState(scope) {
+    let s = drainStates.get(scope);
+    if (!s) {
+        s = { inflight: 0, resolvers: [] };
+        drainStates.set(scope, s);
+    }
+    return s;
+}
+function registerDrainable(scope = 'default') {
+    getState(scope).inflight++;
+}
+function unregisterDrainable(scope = 'default') {
+    const s = getState(scope);
+    s.inflight = Math.max(0, s.inflight - 1);
+    if (s.inflight === 0) {
+        for (const r of s.resolvers)
+            r();
+        s.resolvers = [];
+    }
+}
+/**
+ * Wait for all in-flight act() calls in this scope to settle.
+ * Returns true if all settled within timeoutMs, false if timed out.
+ */
+async function drain(timeoutMs, scope = 'default') {
+    const s = getState(scope);
+    if (s.inflight === 0)
+        return true;
+    return new Promise((resolve) => {
+        let resolved = false;
+        const resolver = () => {
+            if (resolved)
+                return;
+            resolved = true;
+            clearTimeout(timer);
+            // Remove this resolver from the array
+            const idx = s.resolvers.indexOf(resolver);
+            if (idx >= 0)
+                s.resolvers.splice(idx, 1);
+            resolve(true);
+        };
+        const timer = setTimeout(() => {
+            if (resolved)
+                return;
+            resolved = true;
+            // Remove this resolver from the array on timeout
+            const idx = s.resolvers.indexOf(resolver);
+            if (idx >= 0)
+                s.resolvers.splice(idx, 1);
+            resolve(false);
+        }, timeoutMs);
+        s.resolvers.push(resolver);
+    });
+}

package/dist/core/shutdown.d.ts

@@ -0,0 +1,8 @@
+export declare function registerDrainable(scope?: string): void;
+export declare function unregisterDrainable(scope?: string): void;
+/**
+ * Wait for all in-flight act() calls in this scope to settle.
+ * Returns true if all settled within timeoutMs, false if timed out.
+ */
+export declare function drain(timeoutMs: number, scope?: string): Promise<boolean>;
+//# sourceMappingURL=shutdown.d.ts.map

package/dist/core/shutdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown.d.ts","sourceRoot":"","sources":["../../src/core/shutdown.ts"],"names":[],"mappings":"AAaA,wBAAgB,iBAAiB,CAAC,KAAK,SAAY,GAAG,IAAI,CAEzD;AAED,wBAAgB,mBAAmB,CAAC,KAAK,SAAY,GAAG,IAAI,CAO3D;AAED;;;GAGG;AACH,wBAAsB,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,SAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CA0BlF"}

package/dist/core/shutdown.js

@@ -0,0 +1,56 @@
+const drainStates = new Map();
+function getState(scope) {
+    let s = drainStates.get(scope);
+    if (!s) {
+        s = { inflight: 0, resolvers: [] };
+        drainStates.set(scope, s);
+    }
+    return s;
+}
+export function registerDrainable(scope = 'default') {
+    getState(scope).inflight++;
+}
+export function unregisterDrainable(scope = 'default') {
+    const s = getState(scope);
+    s.inflight = Math.max(0, s.inflight - 1);
+    if (s.inflight === 0) {
+        for (const r of s.resolvers)
+            r();
+        s.resolvers = [];
+    }
+}
+/**
+ * Wait for all in-flight act() calls in this scope to settle.
+ * Returns true if all settled within timeoutMs, false if timed out.
+ */
+export async function drain(timeoutMs, scope = 'default') {
+    const s = getState(scope);
+    if (s.inflight === 0)
+        return true;
+    return new Promise((resolve) => {
+        let resolved = false;
+        const resolver = () => {
+            if (resolved)
+                return;
+            resolved = true;
+            clearTimeout(timer);
+            // Remove this resolver from the array
+            const idx = s.resolvers.indexOf(resolver);
+            if (idx >= 0)
+                s.resolvers.splice(idx, 1);
+            resolve(true);
+        };
+        const timer = setTimeout(() => {
+            if (resolved)
+                return;
+            resolved = true;
+            // Remove this resolver from the array on timeout
+            const idx = s.resolvers.indexOf(resolver);
+            if (idx >= 0)
+                s.resolvers.splice(idx, 1);
+            resolve(false);
+        }, timeoutMs);
+        s.resolvers.push(resolver);
+    });
+}
+//# sourceMappingURL=shutdown.js.map

package/dist/core/shutdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown.js","sourceRoot":"","sources":["../../src/core/shutdown.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,GAAG,IAAI,GAAG,EAA8D,CAAA;AAEzF,SAAS,QAAQ,CAAC,KAAa;IAC7B,IAAI,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;IAC9B,IAAI,CAAC,CAAC,EAAE,CAAC;QACP,CAAC,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,CAAA;QAClC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;IAC3B,CAAC;IACD,OAAO,CAAC,CAAA;AACV,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,KAAK,GAAG,SAAS;IACjD,QAAQ,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAA;AAC5B,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,KAAK,GAAG,SAAS;IACnD,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;IACzB,CAAC,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAA;IACxC,IAAI,CAAC,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;QACrB,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS;YAAE,CAAC,EAAE,CAAA;QAChC,CAAC,CAAC,SAAS,GAAG,EAAE,CAAA;IAClB,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,KAAK,CAAC,SAAiB,EAAE,KAAK,GAAG,SAAS;IAC9D,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;IACzB,IAAI,CAAC,CAAC,QAAQ,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IAEjC,OAAO,IAAI,OAAO,CAAU,CAAC,OAAO,EAAE,EAAE;QACtC,IAAI,QAAQ,GAAG,KAAK,CAAA;QACpB,MAAM,QAAQ,GAAG,GAAG,EAAE;YACpB,IAAI,QAAQ;gBAAE,OAAM;YACpB,QAAQ,GAAG,IAAI,CAAA;YACf,YAAY,CAAC,KAAK,CAAC,CAAA;YACnB,sCAAsC;YACtC,MAAM,GAAG,GAAG,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;YACzC,IAAI,GAAG,IAAI,CAAC;gBAAE,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAA;YACxC,OAAO,CAAC,IAAI,CAAC,CAAA;QACf,CAAC,CAAA;QACD,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,IAAI,QAAQ;gBAAE,OAAM;YACpB,QAAQ,GAAG,IAAI,CAAA;YACf,iDAAiD;YACjD,MAAM,GAAG,GAAG,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;YACzC,IAAI,GAAG,IAAI,CAAC;gBAAE,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAA;YACxC,OAAO,CAAC,KAAK,CAAC,CAAA;QAChB,CAAC,EAAE,SAAS,CAAC,CAAA;QAEb,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IAC5B,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/dist/core/tenant.cjs

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTenantStore = createTenantStore;
+exports.createAsyncTenantStore = createAsyncTenantStore;
+const memory_js_1 = require("../stores/memory.js");
+const act_js_1 = require("./act.js");
+const limits_js_1 = require("../utils/limits.js");
+/**
+ * Manages per-tenant stores for multi-tenant isolation.
+ * Each tenant gets its own InMemoryStore — cache/dedupe entries
+ * cannot leak across tenants.
+ */
+function createTenantStore(options = {}) {
+    const maxSize = options.maxSize ?? limits_js_1.LIMITS.DEFAULT_STORE_MAX_SIZE;
+    const autoCleanup = options.autoCleanup ?? true;
+    const cleanupIntervalMs = options.cleanupIntervalMs ?? 60_000;
+    const tenants = new Map();
+    return {
+        get(tenantId) {
+            let entry = tenants.get(tenantId);
+            if (!entry) {
+                const store = new memory_js_1.InMemoryStore({ maxSize, autoCleanup, cleanupIntervalMs });
+                const scoped = (0, act_js_1.withStore)(store);
+                entry = { store, scoped };
+                tenants.set(tenantId, entry);
+            }
+            return entry.scoped;
+        },
+        evict(tenantId) {
+            const entry = tenants.get(tenantId);
+            if (entry) {
+                entry.store.destroy();
+                tenants.delete(tenantId);
+            }
+        },
+        size() {
+            return tenants.size;
+        },
+        destroy() {
+            for (const [, entry] of tenants) {
+                entry.store.destroy();
+            }
+            tenants.clear();
+        },
+    };
+}
+/**
+ * Async tenant manager for async stores (Redis, DynamoDB, etc).
+ * Each tenant gets its own store instance with prefixed keys.
+ */
+function createAsyncTenantStore(storeFactory) {
+    const tenants = new Map();
+    return {
+        get(tenantId) {
+            let entry = tenants.get(tenantId);
+            if (!entry) {
+                const store = storeFactory(tenantId);
+                const scoped = (0, act_js_1.withStore)(store);
+                entry = { store, scoped };
+                tenants.set(tenantId, entry);
+            }
+            return entry.scoped;
+        },
+        evict(tenantId) {
+            tenants.delete(tenantId);
+        },
+        size() {
+            return tenants.size;
+        },
+    };
+}

package/dist/core/tenant.d.ts

@@ -0,0 +1,29 @@
+import type { ScopedActSync, ScopedActAsync } from './act.js';
+import type { AsyncStateStore } from '../stores/base.js';
+export interface TenantStoreOptions {
+    maxSize?: number;
+    autoCleanup?: boolean;
+    cleanupIntervalMs?: number;
+}
+export interface TenantManager {
+    get(tenantId: string): ScopedActSync | ScopedActAsync;
+    evict(tenantId: string): void;
+    size(): number;
+    destroy(): void;
+}
+/**
+ * Manages per-tenant stores for multi-tenant isolation.
+ * Each tenant gets its own InMemoryStore — cache/dedupe entries
+ * cannot leak across tenants.
+ */
+export declare function createTenantStore(options?: TenantStoreOptions): TenantManager;
+/**
+ * Async tenant manager for async stores (Redis, DynamoDB, etc).
+ * Each tenant gets its own store instance with prefixed keys.
+ */
+export declare function createAsyncTenantStore(storeFactory: (tenantId: string) => AsyncStateStore): {
+    get: (tenantId: string) => ScopedActAsync;
+    evict: (tenantId: string) => void;
+    size: () => number;
+};
+//# sourceMappingURL=tenant.d.ts.map

package/dist/core/tenant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../../src/core/tenant.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAE7D,OAAO,KAAK,EAAkB,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAGxE,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,cAAc,CAAA;IACrD,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,IAAI,IAAI,MAAM,CAAA;IACd,OAAO,IAAI,IAAI,CAAA;CAChB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,kBAAuB,GAAG,aAAa,CAsCjF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,eAAe,GAClD;IACD,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,cAAc,CAAA;IACzC,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,IAAI,EAAE,MAAM,MAAM,CAAA;CACnB,CAuBA"}

package/dist/core/tenant.js

@@ -0,0 +1,68 @@
+import { InMemoryStore } from '../stores/memory.js';
+import { withStore } from './act.js';
+import { LIMITS } from '../utils/limits.js';
+/**
+ * Manages per-tenant stores for multi-tenant isolation.
+ * Each tenant gets its own InMemoryStore — cache/dedupe entries
+ * cannot leak across tenants.
+ */
+export function createTenantStore(options = {}) {
+    const maxSize = options.maxSize ?? LIMITS.DEFAULT_STORE_MAX_SIZE;
+    const autoCleanup = options.autoCleanup ?? true;
+    const cleanupIntervalMs = options.cleanupIntervalMs ?? 60_000;
+    const tenants = new Map();
+    return {
+        get(tenantId) {
+            let entry = tenants.get(tenantId);
+            if (!entry) {
+                const store = new InMemoryStore({ maxSize, autoCleanup, cleanupIntervalMs });
+                const scoped = withStore(store);
+                entry = { store, scoped };
+                tenants.set(tenantId, entry);
+            }
+            return entry.scoped;
+        },
+        evict(tenantId) {
+            const entry = tenants.get(tenantId);
+            if (entry) {
+                entry.store.destroy();
+                tenants.delete(tenantId);
+            }
+        },
+        size() {
+            return tenants.size;
+        },
+        destroy() {
+            for (const [, entry] of tenants) {
+                entry.store.destroy();
+            }
+            tenants.clear();
+        },
+    };
+}
+/**
+ * Async tenant manager for async stores (Redis, DynamoDB, etc).
+ * Each tenant gets its own store instance with prefixed keys.
+ */
+export function createAsyncTenantStore(storeFactory) {
+    const tenants = new Map();
+    return {
+        get(tenantId) {
+            let entry = tenants.get(tenantId);
+            if (!entry) {
+                const store = storeFactory(tenantId);
+                const scoped = withStore(store);
+                entry = { store, scoped };
+                tenants.set(tenantId, entry);
+            }
+            return entry.scoped;
+        },
+        evict(tenantId) {
+            tenants.delete(tenantId);
+        },
+        size() {
+            return tenants.size;
+        },
+    };
+}
+//# sourceMappingURL=tenant.js.map

package/dist/core/tenant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenant.js","sourceRoot":"","sources":["../../src/core/tenant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAIpC,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAe3C;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,UAA8B,EAAE;IAChE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,MAAM,CAAC,sBAAsB,CAAA;IAChE,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,IAAI,CAAA;IAC/C,MAAM,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,IAAI,MAAM,CAAA;IAE7D,MAAM,OAAO,GAAG,IAAI,GAAG,EAA2D,CAAA;IAElF,OAAO;QACL,GAAG,CAAC,QAAgB;YAClB,IAAI,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;YACjC,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,MAAM,KAAK,GAAG,IAAI,aAAa,CAAC,EAAE,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,CAAC,CAAA;gBAC5E,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAkB,CAAA;gBAChD,KAAK,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,CAAA;gBACzB,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAA;YAC9B,CAAC;YACD,OAAO,KAAK,CAAC,MAAM,CAAA;QACrB,CAAC;QAED,KAAK,CAAC,QAAgB;YACpB,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;YACnC,IAAI,KAAK,EAAE,CAAC;gBACV,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAA;gBACrB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;YAC1B,CAAC;QACH,CAAC;QAED,IAAI;YACF,OAAO,OAAO,CAAC,IAAI,CAAA;QACrB,CAAC;QAED,OAAO;YACL,KAAK,MAAM,CAAC,EAAE,KAAK,CAAC,IAAI,OAAO,EAAE,CAAC;gBAChC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAA;YACvB,CAAC;YACD,OAAO,CAAC,KAAK,EAAE,CAAA;QACjB,CAAC;KACF,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CACpC,YAAmD;IAMnD,MAAM,OAAO,GAAG,IAAI,GAAG,EAA8D,CAAA;IAErF,OAAO;QACL,GAAG,CAAC,QAAgB;YAClB,IAAI,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;YACjC,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,MAAM,KAAK,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;gBACpC,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAmB,CAAA;gBACjD,KAAK,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,CAAA;gBACzB,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAA;YAC9B,CAAC;YACD,OAAO,KAAK,CAAC,MAAM,CAAA;QACrB,CAAC;QAED,KAAK,CAAC,QAAgB;YACpB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;QAC1B,CAAC;QAED,IAAI;YACF,OAAO,OAAO,CAAC,IAAI,CAAA;QACrB,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/errors.cjs

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Actly error taxonomy.
+ *
+ * Six classes (one abstract base + five concrete). Each carries a stable
+ * `code` field so consumers can switch on strings instead of brittle
+ * `instanceof` chains across realm boundaries (e.g. errors serialised
+ * over IPC).
+ *
+ * # Why these six?
+ *
+ *  - `ActlyError`         — abstract base for `instanceof ActlyError` checks
+ *  - `ActlyAbortError`    — caller / signal cancellation
+ *  - `TimeoutError`       — per-attempt deadline
+ *  - `TotalTimeoutError`  — operation-wide budget
+ *  - `RetryExhaustedError`— last attempt's error wrapped with context
+ *  - `ValidationError`    — programmer error (invalid options)
+ *
+ * NO circuit/bulkhead/rate-limit errors — those policies don't exist in
+ * core. Adding orphan error classes violates the "every feature must map
+ * to a real runtime failure mode" rule.
+ *
+ * # `code` field
+ *
+ * Stable string identifier. Use this for switch statements and telemetry
+ * tags. The class name can change across versions; `code` won't.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitError = exports.BulkheadOverflowError = exports.CircuitBreakerOpenError = exports.ValidationError = exports.RetryExhaustedError = exports.TotalTimeoutError = exports.TimeoutError = exports.ActlyAbortError = exports.ActlyError = void 0;
+/** Base class for all actly errors. Enables `instanceof ActlyError` checks. */
+class ActlyError extends Error {
+    /** The key associated with the failure, if applicable. */
+    key;
+    constructor(message, options) {
+        super(message, options?.cause !== undefined ? { cause: options.cause } : undefined);
+        this.name = new.target.name;
+        if (options?.key !== undefined) {
+            Object.defineProperty(this, 'key', { value: options.key, enumerable: true });
+        }
+        // Restore prototype chain after Error inheritance (TS es2022 target
+        // may strip it). This ensures `instanceof` works correctly.
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.ActlyError = ActlyError;
+/**
+ * Thrown when the caller's signal, per-attempt timeout, or total timeout
+ * aborts the operation.
+ *
+ * `cause` carries the original abort reason (e.g. user-supplied
+ * `controller.abort(new Error('user-cancelled'))` → cause.message is
+ * 'user-cancelled').
+ *
+ * Wraps the raw abort reason in a typed error so consumers can
+ * `instanceof`-check it consistently across all abort sources.
+ */
+class ActlyAbortError extends ActlyError {
+    code = 'ACTLY_ABORT';
+    constructor(options) {
+        const causeMsg = options?.cause instanceof Error ? options.cause.message : String(options?.cause ?? 'aborted');
+        super(`Actly operation aborted: ${causeMsg}`, options);
+    }
+}
+exports.ActlyAbortError = ActlyAbortError;
+/**
+ * Thrown when a per-attempt `timeout` deadline fires.
+ *
+ * Carries the configured `ms` so callers can log/alert precisely:
+ *
+ * ```ts
+ * if (!result.ok && result.error instanceof TimeoutError) {
+ *   console.log(`attempt timed out after ${result.error.ms}ms`)
+ * }
+ * ```
+ */
+class TimeoutError extends ActlyError {
+    code = 'ACTLY_TIMEOUT';
+    ms;
+    constructor(ms, options) {
+        super(`ACT timed out after ${ms}ms`, options);
+        this.ms = ms;
+    }
+}
+exports.TimeoutError = TimeoutError;
+/**
+ * Thrown when the operation-wide `totalTimeout` budget fires.
+ *
+ * Distinct from `TimeoutError` (per-attempt) so callers can `instanceof`-check
+ * which deadline fired.
+ */
+class TotalTimeoutError extends ActlyError {
+    code = 'ACTLY_TOTAL_TIMEOUT';
+    ms;
+    constructor(ms, options) {
+        super(`ACT total timeout exceeded after ${ms}ms`, options);
+        this.ms = ms;
+    }
+}
+exports.TotalTimeoutError = TotalTimeoutError;
+/**
+ * Thrown when all retry attempts are exhausted. The `lastError` is the
+ * final attempt's error; `errors` is the array of all attempt errors
+ * (useful for debugging patterns across retries).
+ *
+ * Wraps retry exhaustion with context so consumers can distinguish "single
+ * fn error" from "retry exhausted after N attempts".
+ *
+ * # When is this thrown vs the raw error?
+ *
+ * `retryPolicy` throws `RetryExhaustedError` when:
+ *  - `attempts > 1` AND
+ *  - all attempts failed AND
+ *  - the default `shouldRetry` (or user-supplied predicate) returned `true`
+ *    for at least one failure
+ *
+ * If the user's `shouldRetry` returns `false` on the first attempt, the
+ * raw error is thrown (no retries happened — not "exhausted").
+ */
+class RetryExhaustedError extends ActlyError {
+    code = 'ACTLY_RETRY_EXHAUSTED';
+    attempts;
+    lastError;
+    errors;
+    constructor(options) {
+        const lastMsg = options.lastError instanceof Error ? options.lastError.message : String(options.lastError);
+        super(`ACT retry exhausted after ${options.attempts} attempts; last error: ${lastMsg}`, { key: options.key, cause: options.lastError });
+        this.attempts = options.attempts;
+        this.lastError = options.lastError;
+        this.errors = options.errors;
+    }
+}
+exports.RetryExhaustedError = RetryExhaustedError;
+/**
+ * Thrown on invalid option shapes / keys / store contracts. Programmer
+ * errors — these surface synchronously, NOT as `ActFailure`, because the
+ * caller's code is broken.
+ *
+ * Wraps the underlying `TypeError` / `RangeError` so consumers catching
+ * `ActlyError` get a consistent type for all actly-thrown errors.
+ */
+class ValidationError extends ActlyError {
+    code = 'ACTLY_VALIDATION';
+    constructor(message, options) {
+        super(message);
+        if (options?.field !== undefined) {
+            Object.defineProperty(this, 'field', { value: options.field, enumerable: true });
+        }
+    }
+    field;
+}
+exports.ValidationError = ValidationError;
+// ─── Hardening error classes ─────────────────────────────────────────────────
+/** Thrown when a circuit breaker is open and blocks the call. */
+class CircuitBreakerOpenError extends ActlyError {
+    code = 'ACTLY_CIRCUIT_OPEN';
+    key;
+    constructor(key, ms) {
+        super(`Circuit breaker open for key "${key}" — retry after ${ms}ms`);
+        this.key = key;
+    }
+}
+exports.CircuitBreakerOpenError = CircuitBreakerOpenError;
+/** Thrown when a bulkhead is full (maxConcurrent reached, queue timed out). */
+class BulkheadOverflowError extends ActlyError {
+    code = 'ACTLY_BULKHEAD_FULL';
+    key;
+    constructor(key, maxConcurrent) {
+        super(`Bulkhead full for key "${key}" — maxConcurrent ${maxConcurrent} reached`);
+        this.key = key;
+    }
+}
+exports.BulkheadOverflowError = BulkheadOverflowError;
+/** Thrown when a rate limit is exceeded. */
+class RateLimitError extends ActlyError {
+    code = 'ACTLY_RATE_LIMIT';
+    key;
+    constructor(key, maxCalls, windowMs) {
+        super(`Rate limit exceeded for key "${key}" — ${maxCalls} calls per ${windowMs}ms`);
+        this.key = key;
+    }
+}
+exports.RateLimitError = RateLimitError;