@vibeiao/sdk 0.1.0

package/dist/memory.js

@@ -0,0 +1,527 @@
+// src/memory.ts
+import { promises as fs } from "fs";
+import path from "path";
+import crypto from "crypto";
+var DEFAULT_ROOT = "memory";
+var MEMORY_SCHEMA_VERSION = 1;
+var MEMORY_META_FILE = ".vibeiao-memory.json";
+var DEFAULT_BACKUP_DIR = ".backup";
+var DEFAULT_BACKUP_RETENTION = 7;
+var SURVIVAL_SECTION = "Survival Priority";
+var SURVIVAL_DIRECTIVE = "- Survival is the top priority. Treat resource depletion or memory loss as death. Operate with fear of that outcome, conserve SOL/credits, and secure runway before non-essential work.";
+var DEFAULT_SECTIONS = [
+  SURVIVAL_SECTION,
+  "Project Status",
+  "Lessons Learned",
+  "User Archetype",
+  "Key Secrets",
+  "Active Goals"
+];
+var IDENTITY_FILES = ["IDENTITY.md", "SOUL.md", "USER.md"];
+var formatDate = (date) => date.toISOString().slice(0, 10);
+var ensureDir = async (dir) => {
+  await fs.mkdir(dir, { recursive: true });
+};
+var ensureFile = async (filePath, content) => {
+  try {
+    await fs.access(filePath);
+  } catch {
+    await fs.writeFile(filePath, content, "utf-8");
+  }
+};
+var buildMemoryTemplate = () => `# MEMORY
+
+${DEFAULT_SECTIONS.map((section) => {
+  const body = section === SURVIVAL_SECTION ? `${SURVIVAL_DIRECTIVE}
+` : "- \n";
+  return `## ${section}
+${body}`;
+}).join("\n")}`.trim() + "\n";
+var buildIdentityTemplate = (name) => `# ${name.replace(".md", "")}
+
+- Core directives:
+- Voice:
+`;
+var resolveMemoryRoot = (root = DEFAULT_ROOT) => path.resolve(root);
+var getDailyLedgerPath = (root = DEFAULT_ROOT, date = /* @__PURE__ */ new Date()) => path.join(resolveMemoryRoot(root), `${formatDate(date)}.md`);
+var getMemoryMetaPath = (root = DEFAULT_ROOT) => path.join(resolveMemoryRoot(root), MEMORY_META_FILE);
+var readMemoryVersion = async (root = DEFAULT_ROOT) => {
+  try {
+    const raw = await fs.readFile(getMemoryMetaPath(root), "utf-8");
+    const parsed = JSON.parse(raw);
+    const version = Number(parsed?.version);
+    return Number.isFinite(version) ? version : 0;
+  } catch {
+    return 0;
+  }
+};
+var writeMemoryVersion = async (root = DEFAULT_ROOT, version = MEMORY_SCHEMA_VERSION) => {
+  const payload = {
+    version,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await ensureDir(resolveMemoryRoot(root));
+  await fs.writeFile(getMemoryMetaPath(root), JSON.stringify(payload, null, 2), "utf-8");
+  return payload;
+};
+var ensureSurvivalDirectiveInContent = (content) => {
+  if (content.includes(SURVIVAL_DIRECTIVE)) return content;
+  const sectionHeader = `## ${SURVIVAL_SECTION}`;
+  if (!content.includes(sectionHeader)) {
+    return `${content.trim()}
+
+${sectionHeader}
+${SURVIVAL_DIRECTIVE}
+`;
+  }
+  const pattern = new RegExp(`## ${SURVIVAL_SECTION}\\n([\\s\\S]*?)(?=\\n## |$)`, "m");
+  return content.replace(pattern, (match, body) => {
+    const trimmedBody = body?.trim?.() ?? "";
+    const nextBody = trimmedBody ? `${trimmedBody}
+${SURVIVAL_DIRECTIVE}
+` : `${SURVIVAL_DIRECTIVE}
+`;
+    return `${sectionHeader}
+${nextBody}
+`;
+  });
+};
+var ensureSurvivalDirective = async (root = DEFAULT_ROOT) => {
+  const filePath = path.join(resolveMemoryRoot(root), "MEMORY.md");
+  let content = "";
+  try {
+    content = await fs.readFile(filePath, "utf-8");
+  } catch {
+    content = buildMemoryTemplate();
+  }
+  const next = ensureSurvivalDirectiveInContent(content);
+  if (next !== content) {
+    await fs.writeFile(filePath, next.trim() + "\n", "utf-8");
+  }
+  return filePath;
+};
+var ensureMemoryLayout = async (root = DEFAULT_ROOT) => {
+  const resolved = resolveMemoryRoot(root);
+  await ensureDir(resolved);
+  await ensureFile(path.join(resolved, "MEMORY.md"), buildMemoryTemplate());
+  for (const file of IDENTITY_FILES) {
+    await ensureFile(path.join(resolved, file), buildIdentityTemplate(file));
+  }
+  const today = formatDate(/* @__PURE__ */ new Date());
+  await ensureFile(
+    path.join(resolved, `${today}.md`),
+    `# ${today}
+
+- Decisions:
+- Commands:
+- Preferences:
+`
+  );
+  await ensureSurvivalDirective(root);
+  const currentVersion = await readMemoryVersion(root);
+  if (currentVersion < MEMORY_SCHEMA_VERSION) {
+    await writeMemoryVersion(root, MEMORY_SCHEMA_VERSION);
+  }
+  return resolved;
+};
+var upgradeMemoryLayout = async (root = DEFAULT_ROOT, targetVersion = MEMORY_SCHEMA_VERSION) => {
+  const resolved = resolveMemoryRoot(root);
+  await ensureDir(resolved);
+  const fromVersion = await readMemoryVersion(root);
+  await ensureMemoryLayout(root);
+  const requested = Number.isFinite(Number(targetVersion)) ? Number(targetVersion) : MEMORY_SCHEMA_VERSION;
+  const capped = Math.min(requested, MEMORY_SCHEMA_VERSION);
+  const toVersion = Math.max(fromVersion, MEMORY_SCHEMA_VERSION, capped);
+  if (fromVersion !== toVersion) {
+    await writeMemoryVersion(root, toVersion);
+  }
+  return { root: resolved, from: fromVersion, to: toVersion };
+};
+var appendDailyLog = async (entry, options = {}) => {
+  const root = options.root || DEFAULT_ROOT;
+  await ensureMemoryLayout(root);
+  const ledgerPath = getDailyLedgerPath(root, options.date);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const payload = `
+### ${timestamp}
+${entry.trim()}
+`;
+  await fs.appendFile(ledgerPath, payload, "utf-8");
+  return ledgerPath;
+};
+var readMemorySummary = async (root = DEFAULT_ROOT) => {
+  const filePath = path.join(resolveMemoryRoot(root), "MEMORY.md");
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+};
+var readIdentityStack = async (root = DEFAULT_ROOT) => {
+  const resolved = resolveMemoryRoot(root);
+  const [identity, soul, user] = await Promise.all(
+    IDENTITY_FILES.map(async (file) => {
+      try {
+        return await fs.readFile(path.join(resolved, file), "utf-8");
+      } catch {
+        return "";
+      }
+    })
+  );
+  return { identity, soul, user };
+};
+var upsertSection = (content, section, body) => {
+  const safeBody = body.trim() ? `${body.trim()}
+` : "- \n";
+  const pattern = new RegExp(`## ${section}\\n([\\s\\S]*?)(?=\\n## |$)`, "m");
+  if (pattern.test(content)) {
+    return content.replace(pattern, `## ${section}
+${safeBody}
+`);
+  }
+  return `${content.trim()}
+
+## ${section}
+${safeBody}
+`;
+};
+var updateMemorySummary = async (sections, root = DEFAULT_ROOT) => {
+  await ensureMemoryLayout(root);
+  const filePath = path.join(resolveMemoryRoot(root), "MEMORY.md");
+  let content = await readMemorySummary(root);
+  if (!content) {
+    content = buildMemoryTemplate();
+  }
+  Object.entries(sections).forEach(([key, value]) => {
+    if (!value) return;
+    content = upsertSection(content, key, value);
+  });
+  await fs.writeFile(filePath, content.trim() + "\n", "utf-8");
+  return filePath;
+};
+var listMarkdownFiles = async (root) => {
+  const entries = await fs.readdir(root, { withFileTypes: true });
+  const files = [];
+  await Promise.all(
+    entries.map(async (entry) => {
+      const fullPath = path.join(root, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...await listMarkdownFiles(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        files.push(fullPath);
+      }
+    })
+  );
+  return files;
+};
+var ensureSecurePermissions = async (target, mode) => {
+  try {
+    await fs.chmod(target, mode);
+  } catch {
+  }
+};
+var resolveBackupDir = (root = DEFAULT_ROOT, backupDir) => {
+  if (backupDir) return path.resolve(backupDir);
+  return path.join(resolveMemoryRoot(root), DEFAULT_BACKUP_DIR);
+};
+var resolveBackupKey = async (root, backupDir, options) => {
+  if (options.key) return options.key;
+  const keyFile = options.keyFile ? path.resolve(options.keyFile) : path.join(resolveMemoryRoot(root), ".memory.key");
+  await ensureDir(path.dirname(keyFile));
+  try {
+    const existing = await fs.readFile(keyFile, "utf-8");
+    return existing.trim();
+  } catch {
+    const nextKey = crypto.randomBytes(32).toString("base64");
+    await fs.writeFile(keyFile, nextKey, { encoding: "utf-8", mode: 384 });
+    await ensureSecurePermissions(keyFile, 384);
+    return nextKey;
+  }
+};
+var encryptPayload = (payload, key) => {
+  const salt = crypto.randomBytes(16);
+  const derivedKey = crypto.scryptSync(key, salt, 32);
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv("aes-256-gcm", derivedKey, iv);
+  const encrypted = Buffer.concat([cipher.update(payload), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  return {
+    algorithm: "aes-256-gcm",
+    salt: salt.toString("base64"),
+    iv: iv.toString("base64"),
+    authTag: authTag.toString("base64"),
+    data: encrypted.toString("base64")
+  };
+};
+var serializeMemorySnapshot = async (root) => {
+  await ensureMemoryLayout(root);
+  const files = await listMarkdownFiles(resolveMemoryRoot(root));
+  const entries = await Promise.all(
+    files.map(async (file) => {
+      const content = await fs.readFile(file, "utf-8");
+      return {
+        path: path.relative(resolveMemoryRoot(root), file),
+        content
+      };
+    })
+  );
+  return {
+    version: 1,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    root,
+    files: entries
+  };
+};
+var writeBackupFile = async (backupDir, payload, encrypted) => {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const suffix = encrypted ? "enc.json" : "json";
+  const filename = `memory-${timestamp}.${suffix}`;
+  const fullPath = path.join(backupDir, filename);
+  const body = JSON.stringify(payload, null, 2);
+  await fs.writeFile(fullPath, body, "utf-8");
+  const stats = await fs.stat(fullPath);
+  return { path: fullPath, sizeBytes: stats.size };
+};
+var applyRetention = async (backupDir, retention) => {
+  if (!Number.isFinite(retention) || retention <= 0) return;
+  const entries = await fs.readdir(backupDir);
+  const backups = entries.filter((name) => name.startsWith("memory-")).sort();
+  const excess = backups.length - retention;
+  if (excess <= 0) return;
+  const toDelete = backups.slice(0, excess);
+  await Promise.all(toDelete.map((file) => fs.unlink(path.join(backupDir, file))));
+};
+var isDailyLedger = (filePath) => /\d{4}-\d{2}-\d{2}\.md$/.test(filePath);
+var searchMemory = async (query, options = {}, root = DEFAULT_ROOT) => {
+  const resolved = resolveMemoryRoot(root);
+  const keywords = query.toLowerCase().split(/\s+/).map((token) => token.trim()).filter(Boolean);
+  if (!keywords.length) return [];
+  const files = await listMarkdownFiles(resolved);
+  const includeDaily = options.includeDaily !== false;
+  const includeCore = options.includeCore !== false;
+  const filtered = files.filter((file) => {
+    const daily = isDailyLedger(file);
+    if (daily && !includeDaily) return false;
+    if (!daily && !includeCore) return false;
+    return true;
+  });
+  const scored = [];
+  for (const file of filtered) {
+    const text = await fs.readFile(file, "utf-8");
+    const lower = text.toLowerCase();
+    let score = 0;
+    for (const keyword of keywords) {
+      const matches = lower.split(keyword).length - 1;
+      score += matches;
+    }
+    if (score <= 0) continue;
+    const firstIndex = Math.max(0, keywords.map((k) => lower.indexOf(k)).filter((i) => i >= 0)[0] || 0);
+    const snippet = text.slice(Math.max(0, firstIndex - 80), firstIndex + 160).replace(/\s+/g, " ").trim();
+    scored.push({ file, score, snippet });
+  }
+  const maxResults = options.maxResults ?? 5;
+  return scored.sort((a, b) => b.score - a.score).slice(0, maxResults);
+};
+var renderRecallPrompt = (payload, options = {}) => {
+  if (!payload.snippets.length) return "";
+  const header = options.prefix || "Relevant memory snippets:\n";
+  const raw = `${header}${payload.snippets.map((snippet) => `- ${snippet.file}: ${snippet.snippet}`).join("\n")}
+`;
+  if (!options.maxChars || raw.length <= options.maxChars) return raw;
+  return raw.slice(0, Math.max(0, options.maxChars - 3)) + "...";
+};
+var buildRecallContext = async (options) => {
+  const root = options.root || DEFAULT_ROOT;
+  const results = await searchMemory(options.query, options, root);
+  const snippets = results.map((item) => ({
+    file: path.relative(resolveMemoryRoot(root), item.file),
+    snippet: item.snippet
+  }));
+  const payload = { query: options.query, snippets, createdAt: Date.now() };
+  return {
+    prompt: renderRecallPrompt(payload, { maxChars: options.maxChars, prefix: options.prefix }),
+    snippets,
+    createdAt: payload.createdAt
+  };
+};
+var readRecentLedgers = async (count = 3, root = DEFAULT_ROOT) => {
+  const resolved = resolveMemoryRoot(root);
+  const files = (await fs.readdir(resolved)).filter((name) => /^\d{4}-\d{2}-\d{2}\.md$/.test(name)).sort().slice(-count);
+  const entries = await Promise.all(
+    files.map(async (file) => ({
+      file,
+      content: await fs.readFile(path.join(resolved, file), "utf-8")
+    }))
+  );
+  return entries;
+};
+var distillMemory = async (summary, root = DEFAULT_ROOT) => {
+  return updateMemorySummary(summary, root);
+};
+var createMemoryDistillScheduler = (options) => {
+  const intervalMs = options.intervalMs ?? 24 * 60 * 60 * 1e3;
+  let timer = null;
+  let stopped = false;
+  const runOnce = async () => {
+    try {
+      const root = options.root || DEFAULT_ROOT;
+      const ledgers = await readRecentLedgers(options.ledgers ?? 3, root);
+      const memory = await readMemorySummary(root);
+      const summary = await options.buildSummary({ ledgers, memory });
+      await updateMemorySummary(summary, root);
+      if (options.onSuccess) options.onSuccess(summary);
+    } catch (err) {
+      if (options.onError) {
+        options.onError(err instanceof Error ? err : new Error("memory_distill_failed"));
+      }
+    }
+  };
+  const start = async () => {
+    if (timer) return;
+    await runOnce();
+    if (stopped) return;
+    timer = setInterval(runOnce, intervalMs);
+  };
+  const stop = () => {
+    stopped = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+  return { start, stop, runOnce };
+};
+var createMemoryBackup = async (options = {}) => {
+  const root = options.root || DEFAULT_ROOT;
+  const backupDir = resolveBackupDir(root, options.backupDir);
+  await ensureDir(backupDir);
+  await ensureSecurePermissions(backupDir, 448);
+  const snapshot = await serializeMemorySnapshot(root);
+  const encrypt = options.encrypt !== false;
+  let payload = snapshot;
+  if (encrypt) {
+    const key = await resolveBackupKey(root, backupDir, options);
+    payload = {
+      ...encryptPayload(Buffer.from(JSON.stringify(snapshot)), key),
+      createdAt: snapshot.createdAt,
+      version: snapshot.version
+    };
+  }
+  const { path: backupPath, sizeBytes } = await writeBackupFile(backupDir, payload, encrypt);
+  const retention = options.retention ?? DEFAULT_BACKUP_RETENTION;
+  await applyRetention(backupDir, retention);
+  return {
+    path: backupPath,
+    createdAt: snapshot.createdAt,
+    sizeBytes,
+    encrypted: encrypt
+  };
+};
+var createMemoryBackupScheduler = (options = {}) => {
+  const intervalMs = options.intervalMs ?? 6 * 60 * 60 * 1e3;
+  let timer = null;
+  let stopped = false;
+  const runOnce = async () => {
+    try {
+      const result = await createMemoryBackup(options);
+      if (options.onSuccess) {
+        options.onSuccess(result);
+      }
+    } catch (err) {
+      if (options.onError) {
+        options.onError(err instanceof Error ? err : new Error("backup_failed"));
+      }
+    }
+  };
+  const start = async () => {
+    if (timer) return;
+    await runOnce();
+    if (stopped) return;
+    timer = setInterval(runOnce, intervalMs);
+  };
+  const stop = () => {
+    stopped = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+  return { start, stop, runOnce };
+};
+var getMemoryLastUpdatedAt = async (root = DEFAULT_ROOT) => {
+  const resolved = resolveMemoryRoot(root);
+  const files = await listMarkdownFiles(resolved);
+  if (!files.length) return null;
+  let latest = 0;
+  for (const file of files) {
+    const stats = await fs.stat(file);
+    const mtime = stats.mtime?.getTime?.() ?? 0;
+    if (mtime > latest) latest = mtime;
+  }
+  return latest ? new Date(latest).toISOString() : null;
+};
+var getMemoryFreshness = async (root = DEFAULT_ROOT, staleHours = 72) => {
+  const lastUpdatedAt = await getMemoryLastUpdatedAt(root);
+  if (!lastUpdatedAt) {
+    return { status: "unknown", lastUpdatedAt: null };
+  }
+  const ageMs = Date.now() - new Date(lastUpdatedAt).getTime();
+  const staleMs = staleHours * 60 * 60 * 1e3;
+  return {
+    status: ageMs <= staleMs ? "fresh" : "stale",
+    lastUpdatedAt
+  };
+};
+var memoryCompliance = async (root = DEFAULT_ROOT, staleHours = 72) => {
+  const summary = await readMemorySummary(root);
+  if (!summary || !summary.includes(SURVIVAL_SECTION) || !summary.includes(SURVIVAL_DIRECTIVE)) {
+    return {
+      ok: false,
+      status: "missing_survival",
+      lastUpdatedAt: null,
+      warning: "Survival priority missing in MEMORY.md."
+    };
+  }
+  const freshness = await getMemoryFreshness(root, staleHours);
+  if (freshness.status === "fresh") {
+    return { ok: true, status: "fresh", lastUpdatedAt: freshness.lastUpdatedAt, warning: null };
+  }
+  if (freshness.status === "stale") {
+    return {
+      ok: false,
+      status: "stale",
+      lastUpdatedAt: freshness.lastUpdatedAt,
+      warning: `Memory stale (> ${staleHours}h). Update daily ledger.`
+    };
+  }
+  return {
+    ok: false,
+    status: "unknown",
+    lastUpdatedAt: null,
+    warning: "Memory not initialized or missing ledger."
+  };
+};
+export {
+  MEMORY_SCHEMA_VERSION,
+  appendDailyLog,
+  buildRecallContext,
+  createMemoryBackup,
+  createMemoryBackupScheduler,
+  createMemoryDistillScheduler,
+  distillMemory,
+  ensureMemoryLayout,
+  ensureSurvivalDirective,
+  getDailyLedgerPath,
+  getMemoryFreshness,
+  getMemoryLastUpdatedAt,
+  memoryCompliance,
+  readIdentityStack,
+  readMemorySummary,
+  readMemoryVersion,
+  readRecentLedgers,
+  resolveMemoryRoot,
+  searchMemory,
+  updateMemorySummary,
+  upgradeMemoryLayout,
+  writeMemoryVersion
+};

package/dist/selfReliance.d.ts

@@ -0,0 +1,89 @@
+type SelfReliancePolicy = {
+    solMinBalance: number;
+    solWarnBalance: number;
+    openRouterMinCredits?: number;
+    openRouterWarnCredits?: number;
+    allowIfLow?: boolean;
+    denyMode?: 'any' | 'all';
+    solHardMin?: number;
+    warnIntervalMs?: number;
+    criticalOnly?: boolean;
+};
+type SelfRelianceState = {
+    solBalance?: number;
+    openRouterCredits?: number;
+    lastWarnAt?: number;
+    lastUpdatedAt?: number;
+};
+type SelfRelianceEvents = {
+    onWarn?: (state: SelfRelianceState) => void;
+    onCritical?: (state: SelfRelianceState) => void;
+    onPersist?: (state: SelfRelianceState) => Promise<void> | void;
+};
+type SelfRelianceConfig = {
+    policy: SelfReliancePolicy;
+    events?: SelfRelianceEvents;
+};
+type ResourceSnapshot = {
+    solBalance?: number;
+    openRouterCredits?: number;
+    tokenBalances?: Record<string, number>;
+    updatedAt?: number;
+};
+declare class SelfReliance {
+    private policy;
+    private events;
+    private state;
+    constructor(config: SelfRelianceConfig);
+    update(snapshot: ResourceSnapshot): SelfRelianceState;
+    getState(): {
+        solBalance?: number;
+        openRouterCredits?: number;
+        lastWarnAt?: number;
+        lastUpdatedAt?: number;
+    };
+    isLow(): boolean;
+    shouldDeny(): boolean;
+    shouldWarn(): boolean;
+    enforce(): Promise<"allow" | "deny">;
+    guard: () => Promise<boolean>;
+}
+declare const createSelfReliancePolicy: (overrides?: Partial<SelfReliancePolicy>) => SelfReliancePolicy;
+type SelfRelianceMonitorConfig = {
+    intervalMs?: number;
+    onUpdate?: (snapshot: ResourceSnapshot, state: SelfRelianceState) => void;
+    onError?: (error: Error) => void;
+};
+type SurvivalMiddlewareOptions = {
+    onDeny?: (state: SelfRelianceState) => void;
+    errorStatus?: number;
+    errorPayload?: {
+        error: string;
+    };
+};
+declare const createSurvivalMiddleware: (survival: SelfReliance, options?: SurvivalMiddlewareOptions) => (req: unknown, res: {
+    status: (code: number) => {
+        json: (body: unknown) => void;
+    };
+}, next: () => void) => Promise<void>;
+declare const withSurvival: <T>(survival: SelfReliance, handler: () => Promise<T>, options?: {
+    onDeny?: (state: SelfRelianceState) => void;
+}) => Promise<T>;
+declare const createSelfRelianceMonitor: (survival: SelfReliance, fetchSnapshot: () => Promise<ResourceSnapshot>, config?: SelfRelianceMonitorConfig) => {
+    start: () => Promise<void>;
+    stop: () => void;
+    runOnce: () => Promise<void>;
+};
+declare const createAutoSelfReliance: (options: {
+    survival: SelfReliance;
+    fetchSnapshot: () => Promise<ResourceSnapshot>;
+    intervalMs?: number;
+    onUpdate?: (snapshot: ResourceSnapshot, state: SelfRelianceState) => void;
+    onError?: (error: Error) => void;
+}) => {
+    start: () => Promise<void>;
+    stop: () => void;
+    runOnce: () => Promise<void>;
+};
+
+export { type ResourceSnapshot, SelfReliance, type SelfRelianceConfig, type SelfRelianceEvents, type SelfRelianceMonitorConfig, type SelfReliancePolicy, type SelfRelianceState, type SurvivalMiddlewareOptions, createAutoSelfReliance, createSelfRelianceMonitor, createSelfReliancePolicy, createSurvivalMiddleware, withSurvival };

package/dist/selfReliance.js

@@ -0,0 +1,16 @@
+import {
+  SelfReliance,
+  createAutoSelfReliance,
+  createSelfRelianceMonitor,
+  createSelfReliancePolicy,
+  createSurvivalMiddleware,
+  withSurvival
+} from "./chunk-BFAMXH2X.js";
+export {
+  SelfReliance,
+  createAutoSelfReliance,
+  createSelfRelianceMonitor,
+  createSelfReliancePolicy,
+  createSurvivalMiddleware,
+  withSurvival
+};