@ultrst-armada/kloks 1.4.2 → 1.4.4

package/packages/backend/dist/chunk-TY32TUNI.js

@@ -0,0 +1,376 @@
+// ../../node_modules/.pnpm/@ultrst-armada+krnl@1.0.3/node_modules/@ultrst-armada/krnl/packages/core/dist/index.js
+var ServiceStateStore = class {
+  state;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(initialState) {
+    this.state = { ...initialState };
+  }
+  getState() {
+    return Object.freeze({ ...this.state });
+  }
+  setState(mutation) {
+    this.state = { ...this.state, ...mutation };
+    const snapshot = this.getState();
+    for (const listener of this.listeners) {
+      listener(snapshot, mutation);
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  reset(newState) {
+    this.state = { ...newState || {} };
+  }
+};
+var ServiceEventBus = class {
+  handlers = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    const set = this.handlers.get(event);
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  emit(event, payload) {
+    const set = this.handlers.get(event);
+    if (!set) return;
+    for (const handler of Array.from(set)) {
+      try {
+        handler(payload);
+      } catch (err) {
+        console.error(`[ServiceEventBus] Handler error for '${event}':`, err);
+      }
+    }
+  }
+  clear() {
+    this.handlers.clear();
+  }
+};
+var TRANSITIONS = {
+  uninitialized: ["initializing"],
+  initializing: ["ready", "uninitialized"],
+  ready: ["starting"],
+  starting: ["running", "ready"],
+  running: ["stopping"],
+  stopping: ["stopped", "running"],
+  stopped: ["starting"]
+};
+var LifecycleManager = class {
+  status = "uninitialized";
+  getStatus() {
+    return this.status;
+  }
+  canTransitionTo(next) {
+    return TRANSITIONS[this.status].includes(next);
+  }
+  transitionTo(next) {
+    if (!this.canTransitionTo(next)) {
+      throw new Error("[Lifecycle] Invalid transition '" + this.status + "' -> '" + next + "'.");
+    }
+    this.status = next;
+  }
+  setStatus(next) {
+    this.transitionTo(next);
+  }
+  assertRunning(serviceName) {
+    if (this.status !== "running") {
+      throw new Error(
+        "[Service:" + serviceName + "] Cannot invoke operation while status is '" + this.status + "' (expected 'running')."
+      );
+    }
+  }
+};
+var ServiceInstance = class {
+  constructor(definition) {
+    this.definition = definition;
+    this.id = definition.id;
+    this.name = definition.name;
+    this.version = definition.version;
+    this.lifecycle = new LifecycleManager();
+    this.eventBus = new ServiceEventBus();
+    if (definition.state) {
+      this.stateStore = new ServiceStateStore(definition.state.initial);
+    }
+  }
+  definition;
+  id;
+  name;
+  version;
+  stateStore;
+  eventBus;
+  lifecycle;
+  initialized = false;
+  disposed = false;
+  getDefinition() {
+    return this.definition;
+  }
+  getStatus() {
+    return this.lifecycle.getStatus();
+  }
+  async start() {
+    if (this.disposed) throw new Error("[Service:" + this.name + "] Cannot start a disposed service.");
+    const current = this.lifecycle.getStatus();
+    if (current === "running") return;
+    if (current === "initializing" || current === "starting" || current === "stopping") {
+      throw new Error("[Service:" + this.name + "] Cannot start while status is '" + current + "'.");
+    }
+    if (!this.initialized) {
+      this.lifecycle.transitionTo("initializing");
+      try {
+        await this.definition.lifecycle?.onInit?.();
+        this.initialized = true;
+        this.lifecycle.transitionTo("ready");
+      } catch (error) {
+        this.lifecycle.transitionTo("uninitialized");
+        throw error;
+      }
+    }
+    this.lifecycle.transitionTo("starting");
+    try {
+      await this.definition.lifecycle?.onStart?.();
+      this.lifecycle.transitionTo("running");
+    } catch (error) {
+      this.lifecycle.transitionTo("ready");
+      throw error;
+    }
+  }
+  async stop() {
+    const current = this.lifecycle.getStatus();
+    if (current === "stopped") return;
+    if (current !== "running") {
+      throw new Error("[Service:" + this.name + "] Cannot stop while status is '" + current + "'.");
+    }
+    this.lifecycle.transitionTo("stopping");
+    try {
+      await this.definition.lifecycle?.onStop?.();
+      this.lifecycle.transitionTo("stopped");
+    } catch (error) {
+      this.lifecycle.transitionTo("running");
+      throw error;
+    }
+  }
+  async dispose() {
+    if (this.disposed) return;
+    if (this.lifecycle.getStatus() === "running") await this.stop();
+    await this.definition.lifecycle?.onDispose?.();
+    this.disposed = true;
+  }
+  async call(op, input, ctx = {}) {
+    this.lifecycle.assertRunning(this.name);
+    const operation = this.definition.operations[op];
+    if (!operation) {
+      throw new Error("[Service:" + this.name + "] Operation '" + op + "' not found.");
+    }
+    return await operation.handler(input, ctx);
+  }
+  getState() {
+    return this.stateStore?.getState() ?? Object.freeze({});
+  }
+  setState(mutation) {
+    if (!this.stateStore) {
+      this.stateStore = new ServiceStateStore({ ...mutation });
+      return;
+    }
+    this.stateStore.setState(mutation);
+  }
+  on(event, handler) {
+    return this.eventBus.on(event, handler);
+  }
+  emit(event, payload) {
+    this.eventBus.emit(event, payload);
+  }
+};
+var ServiceProxy = class {
+  constructor(definition, adapter, endpoint) {
+    this.definition = definition;
+    this.adapter = adapter;
+    this.endpoint = endpoint;
+    if (!definition) {
+      throw new Error("[ServiceProxy] Missing service definition.");
+    }
+    if (!adapter || typeof adapter.send !== "function") {
+      throw new Error("[ServiceProxy:" + (definition.name || "unknown") + "] Missing or invalid protocol adapter.");
+    }
+    if (!endpoint || typeof endpoint.address !== "string" || endpoint.address.length === 0) {
+      throw new Error("[ServiceProxy:" + (definition.name || "unknown") + "] Missing or invalid endpoint descriptor.");
+    }
+    this.id = definition.id;
+    this.name = definition.name;
+    this.version = definition.version;
+    this.stateCache = { ...definition.state?.initial ?? {} };
+  }
+  definition;
+  adapter;
+  endpoint;
+  id;
+  name;
+  version;
+  stateCache;
+  eventHandlers = /* @__PURE__ */ new Map();
+  lifecycle = new LifecycleManager();
+  disposed = false;
+  getDefinition() {
+    return this.definition;
+  }
+  getStatus() {
+    return this.lifecycle.getStatus();
+  }
+  async start() {
+    if (this.disposed) {
+      throw new Error("[ServiceProxy:" + this.name + "] Cannot start a disposed service proxy.");
+    }
+    const status = this.lifecycle.getStatus();
+    if (status === "running") return;
+    if (status === "stopping" || status === "starting" || status === "initializing") {
+      throw new Error("[ServiceProxy:" + this.name + "] Cannot start while status is '" + status + "'.");
+    }
+    if (status === "uninitialized") {
+      this.lifecycle.transitionTo("initializing");
+      this.lifecycle.transitionTo("ready");
+    }
+    this.lifecycle.transitionTo("starting");
+    this.lifecycle.transitionTo("running");
+  }
+  async stop() {
+    const status = this.lifecycle.getStatus();
+    if (status === "stopped") return;
+    if (status !== "running") {
+      throw new Error("[ServiceProxy:" + this.name + "] Cannot stop while status is '" + status + "'.");
+    }
+    this.lifecycle.transitionTo("stopping");
+    this.lifecycle.transitionTo("stopped");
+  }
+  async dispose() {
+    if (this.disposed) return;
+    if (this.lifecycle.getStatus() === "running") await this.stop();
+    this.disposed = true;
+  }
+  async call(op, input, ctx = {}) {
+    if (!this.definition.operations[op]) {
+      throw new Error("[ServiceProxy:" + this.name + "] Operation '" + op + "' not found.");
+    }
+    if (this.lifecycle.getStatus() !== "running") {
+      await this.start();
+    }
+    if (!this.adapter.send) {
+      throw new Error("[ServiceProxy:" + this.name + "] Adapter does not support send().");
+    }
+    const envelope = {
+      id: "req-" + Date.now() + "-" + Math.random().toString(36).slice(2, 7),
+      type: "request",
+      operation: op,
+      payload: input,
+      timestamp: Date.now()
+    };
+    const response = await this.adapter.send(this.endpoint, envelope);
+    if (response.error) {
+      throw new Error("[ServiceProxy:" + this.name + "] Remote error: " + response.error);
+    }
+    return response.payload;
+  }
+  getState() {
+    return Object.freeze({ ...this.stateCache });
+  }
+  setState(mutation) {
+    this.stateCache = { ...this.stateCache, ...mutation };
+  }
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    const handlers = this.eventHandlers.get(event);
+    handlers.add(handler);
+    return () => handlers.delete(handler);
+  }
+  emit(event, payload) {
+    const handlers = this.eventHandlers.get(event);
+    if (!handlers) return;
+    for (const handler of Array.from(handlers)) {
+      try {
+        handler(payload);
+      } catch (error) {
+        console.error("[ServiceProxy:" + this.name + "] Event handler error for '" + event + "':", error);
+      }
+    }
+  }
+};
+function assertRecord(value, field) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("[KrnlTS] Invalid service definition: '" + field + "' must be an object.");
+  }
+}
+function assertNonEmptyString(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error("[KrnlTS] Invalid service definition: '" + field + "' must be a non-empty string.");
+  }
+}
+function validateServiceDefinition(definition) {
+  if (!definition || typeof definition !== "object") {
+    throw new Error("[KrnlTS] Invalid service definition: expected an object.");
+  }
+  assertNonEmptyString(definition.id, "id");
+  assertNonEmptyString(definition.name, "name");
+  assertNonEmptyString(definition.version, "version");
+  if (!definition.operations || typeof definition.operations !== "object") {
+    throw new Error("[Service:" + definition.name + "] Invalid operations: expected an object.");
+  }
+  for (const [key, operation] of Object.entries(definition.operations)) {
+    if (!operation || typeof operation !== "object") {
+      throw new Error("[Service:" + definition.name + "] Invalid operation '" + key + "'.");
+    }
+    assertNonEmptyString(operation.id, "operations." + key + ".id");
+    assertNonEmptyString(operation.name, "operations." + key + ".name");
+    if (operation.inputSchema !== void 0) assertRecord(operation.inputSchema, "operations." + key + ".inputSchema");
+    if (operation.outputSchema !== void 0) assertRecord(operation.outputSchema, "operations." + key + ".outputSchema");
+    if (typeof operation.handler !== "function") {
+      throw new Error("[Service:" + definition.name + "] Operation '" + key + "' must define a handler.");
+    }
+  }
+  for (const [key, event] of Object.entries(definition.events ?? {})) {
+    if (!event || typeof event !== "object") {
+      throw new Error("[Service:" + definition.name + "] Invalid event '" + key + "'.");
+    }
+    assertNonEmptyString(event.name, "events." + key + ".name");
+  }
+  for (const [key, schema] of Object.entries(definition.inputs ?? {})) assertRecord(schema, "inputs." + key);
+  for (const [key, schema] of Object.entries(definition.outputs ?? {})) assertRecord(schema, "outputs." + key);
+  if (definition.state?.schema !== void 0) assertRecord(definition.state.schema, "state.schema");
+  for (const capability of definition.capabilities ?? []) {
+    assertNonEmptyString(capability.id, "capability.id");
+    assertNonEmptyString(capability.name, "capability.name");
+    if (!Array.isArray(capability.protocols)) {
+      throw new Error("[Service:" + definition.name + "] Capability '" + capability.name + "' protocols must be an array.");
+    }
+  }
+  for (const dependency of definition.dependencies ?? []) {
+    assertNonEmptyString(dependency.serviceId, "dependency.serviceId");
+  }
+  return definition;
+}
+function createServiceDefinition(definition) {
+  return validateServiceDefinition(definition);
+}
+function createService(definition) {
+  return new ServiceInstance(validateServiceDefinition(definition));
+}
+function createServiceProxy(definition, adapter, endpoint) {
+  validateServiceDefinition(definition);
+  if (!adapter || typeof adapter.send !== "function") {
+    throw new Error("[ServiceProxy:" + definition.name + "] Adapter must implement send().");
+  }
+  if (!endpoint || typeof endpoint.address !== "string" || endpoint.address.length === 0) {
+    throw new Error("[ServiceProxy:" + definition.name + "] Endpoint must have an address.");
+  }
+  return new ServiceProxy(definition, adapter, endpoint);
+}
+var asyncHooks = globalThis.process?.getBuiltinModule?.("node:async_hooks");
+
+export {
+  createServiceDefinition,
+  createService,
+  createServiceProxy
+};

package/packages/backend/dist/chunk-VDROUXFT.js

@@ -0,0 +1,116 @@
+import {
+  b2ListBuckets
+} from "./chunk-4QEMALXF.js";
+
+// src/srkl/SrklDiscoveryService.ts
+var cachedSrklUrl = null;
+async function getPrimarySrklDeploymentUrl(queryDb) {
+  if (cachedSrklUrl && Date.now() < cachedSrklUrl.expiresAt) return cachedSrklUrl.url;
+  if (queryDb) {
+    try {
+      const res = await queryDb(
+        `SELECT url FROM "ultrst-srkl-deployments" WHERE is_active = true ORDER BY is_primary DESC, priority DESC, created_at ASC LIMIT 1`,
+        []
+      );
+      if (res.rows.length > 0 && res.rows[0].url) {
+        const url = res.rows[0].url.trim().replace(/\/+$/, "");
+        cachedSrklUrl = { url, expiresAt: Date.now() + 10 * 60 * 1e3 };
+        return url;
+      }
+    } catch {
+    }
+  }
+  const fallback = "https://srkl-engine.vercel.app";
+  cachedSrklUrl = { url: fallback, expiresAt: Date.now() + 10 * 60 * 1e3 };
+  return fallback;
+}
+async function getSrklAccounts(userId, service, queryDb) {
+  const srklUrl = await getPrimarySrklDeploymentUrl(queryDb);
+  const accounts = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  if (queryDb && userId) {
+    try {
+      const uRes = await queryDb(`SELECT app_profiles FROM "ultrst-users" WHERE id = $1 LIMIT 1`, [userId]);
+      if (uRes.rows.length > 0) {
+        const p = typeof uRes.rows[0].app_profiles === "string" ? JSON.parse(uRes.rows[0].app_profiles) : uRes.rows[0].app_profiles || {};
+        const pool = [
+          ...p.srkl?.storage_connections || [],
+          ...p.depm?.storage_connections || [],
+          ...p.qwnsr?.storage_connections || [],
+          ...p.loky?.storage_connections || []
+        ];
+        for (const conn of pool) {
+          if (service && !conn.provider?.toLowerCase().includes(service.toLowerCase())) continue;
+          const kId = (conn.b2KeyId || conn.keyId || conn.accessKeyId || "").trim();
+          const key = kId ? `key:${kId}` : `id:${conn.id}`;
+          if (!seenKeys.has(key)) {
+            seenKeys.add(key);
+            accounts.push({
+              id: conn.id,
+              name: conn.label || conn.id,
+              provider: conn.provider,
+              serviceId: conn.provider,
+              credentials: {
+                keyId: conn.b2KeyId || conn.keyId,
+                applicationKey: conn.b2ApplicationKey || conn.appKey,
+                bucketName: conn.b2BucketName || conn.bucketName,
+                region: conn.b2Region || conn.region,
+                endpoint: conn.b2Endpoint || conn.endpoint
+              }
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const res = await fetch(`${srklUrl}/api/ecosystem/services`, {
+      headers: { "x-user-id": userId, Accept: "application/json" },
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (res.ok) {
+      const data = await res.json();
+      const list = Array.isArray(data.services) ? data.services : [];
+      for (const item of list) {
+        const sId = String(item.serviceId || item.id || "").toLowerCase();
+        if (service && !sId.includes(service.toLowerCase())) continue;
+        const kId = (item.credentials?.keyId || item.credentials?.b2KeyId || "").trim();
+        const key = kId ? `key:${kId}` : `id:${item.id}`;
+        if (!seenKeys.has(key)) {
+          seenKeys.add(key);
+          accounts.push(item);
+        }
+      }
+    }
+  } catch {
+  }
+  return { success: true, deploymentUrl: srklUrl, count: accounts.length, accounts };
+}
+async function srklListBackblazeBuckets(keyId, applicationKey, _bucketId, _bucketName, userId, queryDb) {
+  let resolvedKeyId = (keyId || "").trim();
+  let resolvedAppKey = (applicationKey || "").trim();
+  if ((!resolvedKeyId || !resolvedAppKey) && userId && queryDb) {
+    const accountsRes = await getSrklAccounts(userId, "backblaze", queryDb);
+    const matched = accountsRes.accounts.find((a) => (a.credentials?.keyId || a.credentials?.b2KeyId) === resolvedKeyId) || accountsRes.accounts[0];
+    if (matched) {
+      resolvedKeyId = matched.credentials?.keyId || matched.credentials?.b2KeyId || resolvedKeyId;
+      resolvedAppKey = matched.credentials?.applicationKey || matched.credentials?.b2ApplicationKey || resolvedAppKey;
+    }
+  }
+  if (!resolvedKeyId || !resolvedAppKey) {
+    return { success: false, buckets: [], error: "Backblaze B2 Key ID and Application Key are required" };
+  }
+  try {
+    const buckets = await b2ListBuckets(resolvedKeyId, resolvedAppKey);
+    return { success: true, buckets };
+  } catch (err) {
+    return { success: false, buckets: [], error: err.message };
+  }
+}
+
+export {
+  getPrimarySrklDeploymentUrl,
+  getSrklAccounts,
+  srklListBackblazeBuckets
+};

package/packages/backend/dist/chunk-ZDH4XI7W.js

@@ -0,0 +1,140 @@
+// src/auth/SessionManager.ts
+var SessionManager = class {
+  ttl;
+  constructor(ttlMs = 864e5) {
+    this.ttl = ttlMs;
+  }
+  generateToken(userId) {
+    return `sess::${userId}::${Date.now()}::${Math.random().toString(36).substring(2, 9)}`;
+  }
+  createSession(userId, role) {
+    return {
+      token: this.generateToken(userId),
+      userId,
+      role,
+      expiresAt: Date.now() + this.ttl
+    };
+  }
+  isValid(session) {
+    return Date.now() < session.expiresAt;
+  }
+};
+
+// src/auth/RateLimiter.ts
+var RateLimiter = class {
+  attempts = /* @__PURE__ */ new Map();
+  windowMs;
+  maxUser;
+  maxAdmin;
+  constructor(windowMs = 9e5, maxUser = 5, maxAdmin = 3) {
+    this.windowMs = windowMs;
+    this.maxUser = maxUser;
+    this.maxAdmin = maxAdmin;
+  }
+  check(identifier, isAdminAttempt = false) {
+    const now = Date.now();
+    let record = this.attempts.get(identifier);
+    if (!record || now - record.windowStart > this.windowMs) {
+      record = { count: 0, windowStart: now };
+      this.attempts.set(identifier, record);
+    }
+    record.count++;
+    const limit = isAdminAttempt ? this.maxAdmin : this.maxUser;
+    if (record.count > limit) {
+      throw new Error("Too many requests. Please try again later.");
+    }
+  }
+  reset(identifier) {
+    this.attempts.delete(identifier);
+  }
+};
+
+// src/auth/UnifiedAuthCore.ts
+import bcrypt from "bcryptjs";
+async function loginSystemUser(email, rawPass, isAdmin, queryDb) {
+  const normEmail = (email || "").trim().toLowerCase();
+  const password = (rawPass || "").trim();
+  if (!normEmail || !password) {
+    return { success: false, status: 400, error: "Email and password are required" };
+  }
+  try {
+    if (isAdmin) {
+      const credRes = await queryDb(`SELECT * FROM "ultrst-credentials" WHERE id = 'system' LIMIT 1`, []);
+      if (credRes.rows.length > 0) {
+        const cred = credRes.rows[0];
+        const matchEmail = (cred.admin_email || "").toLowerCase() === normEmail;
+        const matchPass = cred.admin_password === password || cred.admin_password && bcrypt.compareSync(password, cred.admin_password);
+        if (matchEmail && matchPass) {
+          return {
+            success: true,
+            status: 200,
+            token: `adm_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+            user: { id: "admin_sys", email: cred.admin_email, username: "System Admin", name: "System Admin", role: "admin", status: "ACTIVE" }
+          };
+        }
+      }
+    }
+    const uRes = await queryDb(`SELECT * FROM "ultrst-users" WHERE LOWER(email) = $1 LIMIT 1`, [normEmail]);
+    if (uRes.rows.length === 0) {
+      return { success: false, status: 401, error: "Invalid email or password" };
+    }
+    const user = uRes.rows[0];
+    const hash = user.password_hash || "";
+    let isMatch = false;
+    if (hash.startsWith("$2a$") || hash.startsWith("$2b$")) {
+      isMatch = bcrypt.compareSync(password, hash);
+    } else {
+      isMatch = hash === password;
+    }
+    if (!isMatch) {
+      return { success: false, status: 401, error: "Invalid email or password" };
+    }
+    if (isAdmin && user.role !== "admin") {
+      return { success: false, status: 403, error: "Insufficient administrative privileges" };
+    }
+    return {
+      success: true,
+      status: 200,
+      token: `usr_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+      user: {
+        id: user.id,
+        email: user.email,
+        username: user.username || user.name || user.email.split("@")[0],
+        name: user.name || user.username || "Ecosystem User",
+        role: user.role || "user",
+        status: user.status || "ACTIVE",
+        appProfiles: typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {}
+      }
+    };
+  } catch (err) {
+    return { success: false, status: 500, error: err.message };
+  }
+}
+async function resolveUserFromToken(tokenOrUserId, queryDb) {
+  if (!tokenOrUserId) return null;
+  let targetId = tokenOrUserId;
+  if (targetId.startsWith("Bearer ")) targetId = targetId.slice(7).trim();
+  if (targetId.startsWith("sess::")) {
+    const parts = targetId.split("::");
+    if (parts[1]) targetId = parts[1];
+  }
+  const res = await queryDb(`SELECT * FROM "ultrst-users" WHERE id = $1 OR LOWER(email) = LOWER($1) LIMIT 1`, [targetId]);
+  if (res.rows.length === 0) return null;
+  const u = res.rows[0];
+  return {
+    id: u.id,
+    email: u.email,
+    username: u.username || u.name || u.email.split("@")[0],
+    name: u.name || u.username || "Ecosystem User",
+    role: u.role || "user",
+    status: u.status || "ACTIVE",
+    appProfiles: typeof u.app_profiles === "string" ? JSON.parse(u.app_profiles) : u.app_profiles || {}
+  };
+}
+
+export {
+  SessionManager,
+  RateLimiter,
+  loginSystemUser,
+  resolveUserFromToken
+};

package/packages/backend/dist/client/index.d.ts

@@ -1,7 +1,6 @@
-import { B as BackendClient, D as DomainProxy, b as BackendResolver, F as FrontendSession } from '../WebSocketTransport-CxUzUfwl.js';
-export { a as BackendClientOptions, c as BackendResolverOptions, C as CallbackFn, d as CallbackRegistry, e as EventBus, f as EventHandler, g as FrontendSessionOptions, G as GapHandler, H as HTTPTransport, h as HTTPTransportOptions, S as SequenceCheckResult, i as SequenceTracker, W as WebSocketTransport, j as WebSocketTransportOptions, k as createBackendClient } from '../WebSocketTransport-CxUzUfwl.js';
+import { B as BackendClient, j as DomainProxy, d as BackendResolver, F as FrontendSession } from '../WebSocketTransport-CHmkJ0tj.js';
+export { a as BackendClientOptions, b as BackendExecutor, e as BackendResolverOptions, C as CallbackFn, f as CallbackHandle, g as CallbackRegistry, D as Delegation, k as EventBus, l as EventHandler, m as FrontendSessionOptions, G as GapHandler, H as HTTPTransport, n as HTTPTransportOptions, J as Job, p as JobPriority, q as JobState, M as Message, s as MessageType, R as ResolutionStrategy, S as SequenceCheckResult, v as SequenceTracker, W as WebSocketTransport, w as WebSocketTransportOptions, x as createBackendClient } from '../WebSocketTransport-CHmkJ0tj.js';
 import React from 'react';
-export { B as BackendExecutor, C as CallbackHandle, D as Delegation, J as Job, d as JobPriority, e as JobState, M as Message, f as MessageType, R as ResolutionStrategy } from '../types-BERZJ93O.js';
 
 /**
  * @file useBackend.ts

package/packages/backend/dist/connectivity/index.d.ts

@@ -1,8 +1,5 @@
-import { g as ResourceVersion, J as Job, a as BackendInstance, h as RoutingStrategy, B as BackendExecutor, M as Message, C as CallbackHandle, D as Delegation } from '../types-BERZJ93O.js';
-export { A as AuthContext, b as CapabilityContext, c as DistributedLock, I as IdempotentRequest, d as JobPriority, e as JobState, f as MessageType, R as ResolutionStrategy } from '../types-BERZJ93O.js';
-import { e as EventBus, d as CallbackRegistry, C as CallbackFn, I as ITransport } from '../WebSocketTransport-CxUzUfwl.js';
-export { B as BackendClient, a as BackendClientOptions, b as BackendResolver, c as BackendResolverOptions, D as DomainProxy, E as ErrorHandler, f as EventHandler, F as FrontendSession, g as FrontendSessionOptions, G as GapHandler, H as HTTPTransport, h as HTTPTransportOptions, M as MessageHandler, S as SequenceCheckResult, i as SequenceTracker, W as WebSocketTransport, j as WebSocketTransportOptions, k as createBackendClient } from '../WebSocketTransport-CxUzUfwl.js';
-export { I as IdempotencyManager } from '../IdempotencyManager-B5MjK871.js';
+import { t as ResourceVersion, J as Job, c as BackendInstance, u as RoutingStrategy, b as BackendExecutor, k as EventBus, g as CallbackRegistry, M as Message, C as CallbackFn, f as CallbackHandle, D as Delegation, I as ITransport } from '../WebSocketTransport-CHmkJ0tj.js';
+export { A as AuthContext, B as BackendClient, a as BackendClientOptions, d as BackendResolver, e as BackendResolverOptions, h as CapabilityContext, i as DistributedLock, j as DomainProxy, E as ErrorHandler, l as EventHandler, F as FrontendSession, m as FrontendSessionOptions, G as GapHandler, H as HTTPTransport, n as HTTPTransportOptions, o as IdempotentRequest, p as JobPriority, q as JobState, r as MessageHandler, s as MessageType, R as ResolutionStrategy, S as SequenceCheckResult, v as SequenceTracker, W as WebSocketTransport, w as WebSocketTransportOptions, x as createBackendClient } from '../WebSocketTransport-CHmkJ0tj.js';
 
 /**
  * @file BackendContract.ts
@@ -114,6 +111,21 @@ declare class LockManager {
     clear(): void;
 }
 
+/**
+ * @file IdempotencyManager.ts
+ * @description In-flight mutation deduplication, concurrent attachment, and completed result caching.
+ */
+declare class IdempotencyManager {
+    private inFlight;
+    private completedCache;
+    private ttlMs;
+    constructor(ttlMs?: number);
+    executeIdempotent<T>(idempotencyKey: string, operation: () => Promise<T>): Promise<T>;
+    has(idempotencyKey: string): boolean;
+    prune(): void;
+    clear(): void;
+}
+
 /**
  * @file JobScheduler.ts
  * @description DAG-based job sequencing engine supporting dependency ordering, priority queues, and concurrency control.
@@ -234,4 +246,4 @@ declare class RemoteExecutor implements BackendExecutor {
     getTransport(): ITransport;
 }
 
-export { type BackendContract, BackendExecutor, BackendInstance, BackendRegistry, type CallbackDefinition, CallbackFn, CallbackHandle, CallbackRegistry, ConcurrencyConflictError, ConcurrencyManager, Delegation, type DomainContract, EventBus, type EventDefinition, HealthMonitor, ITransport, InProcessExecutor, Job, type JobDefinition, type JobHandler, JobScheduler, LoadBalancer, LockManager, Message, type OperationDefinition, RemoteExecutor, type RemoteExecutorOptions, ResourceVersion, RoutingStrategy, createEmptyContract };
+export { type BackendContract, BackendExecutor, BackendInstance, BackendRegistry, type CallbackDefinition, CallbackFn, CallbackHandle, CallbackRegistry, ConcurrencyConflictError, ConcurrencyManager, Delegation, type DomainContract, EventBus, type EventDefinition, HealthMonitor, ITransport, IdempotencyManager, InProcessExecutor, Job, type JobDefinition, type JobHandler, JobScheduler, LoadBalancer, LockManager, Message, type OperationDefinition, RemoteExecutor, type RemoteExecutorOptions, ResourceVersion, RoutingStrategy, createEmptyContract };