openclaw
Version:
Multi-channel AI gateway with extensible messaging integrations
11,709 lines • 486 kB
JavaScript
import { i as extractErrorCode, s as toErrorObject } from "./error-coercion-CwIUUFnu.mjs";
import { t as mergeProcessEnv } from "./process-env-DlZFJzq6.mjs";
import { i as isPidDefinitelyDead, r as isPidAlive, t as getFileLockProcessStartTime } from "./pid-alive-C45jDwYk.mjs";
import { S as registerNodeSqliteKyselyQueryErrorHandler, W as OPENCLAW_DATABASE_SCHEMA_DOCS_URL, _ as executeWithCachedStatement, b as queryErrorHandlerByDatabase, d as isSqliteSchemaVersionError, f as readSqliteUserVersion, h as clearNodeSqliteKyselyCacheForDatabase, i as resolveOpenClawStateDirForDatabasePath, o as resolveOpenClawStateSqlitePath, p as StartupMaintenanceRequiredError, s as resolveQuarantineStorePath, u as createNewerSqliteSchemaVersionError, v as installStatementInvalidation, x as registerNodeSqliteDisposeCallback, y as kyselyByDatabase } from "./openclaw-state-db.paths-JnUZZAu1.mjs";
import { M as isRecord, _ as MAX_TIMER_TIMEOUT_MS, c as normalizeWindowsPathPreservingCase, k as asOptionalObjectRecord, o as isPathInside$1, p as resolveRequiredOsHomeDir } from "./utils-Dor5uhSv.mjs";
import { P as resolveIdentityPathViaExistingAncestorSync, V as containsEnvVarReference, b as resolveStateDir, d as resolveGlobalSingleton, g as resolveGatewayLockDirForCanonicalStateDir, h as resolveGatewayLockDir, j as hasErrnoCode } from "./redact-BwKH5fIe.mjs";
import { n as isAbortError } from "./abort-signal-C9_EQ1qN.mjs";
import { t as formatErrorMessage } from "./errors-C_Op1bVg.mjs";
import { a as expandEnvNormalizationKeys, c as resolveEnvNormalizationKeys, n as isDangerousHostEnvVarName, r as normalizeEnvVarKey, s as normalizeZaiEnv, t as isDangerousHostEnvOverrideVarName } from "./host-env-security-Dw0EukUB.mjs";
import { i as normalizeLegacyDotBetaVersion, n as compareValidSemver, t as compareOpenClawSemver } from "./semver-aYpwYdrQ.mjs";
import { i as sha256HexPrefixCore } from "./crypto-digest-DFe1GlHl.mjs";
import { t as isPromiseLike } from "./promise-like-D7-l5Fsp.mjs";
import { c as registerSignalExitFinalizer, i as getChildLogger, o as resolvePreferredOpenClawTmpDir, t as createSubsystemLogger } from "./subsystem-EYGCijzb.mjs";
import { createRequire } from "node:module";
import "node:v8";
import fsSync, { chmodSync, existsSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
import path, { posix } from "node:path";
import os from "node:os";
import { pathToFileURL } from "node:url";
import { normalizeWindowsPathForComparison } from "@openclaw/fs-safe/path";
import { sameFileIdentity } from "@openclaw/fs-safe/advanced";
import { randomUUID } from "node:crypto";
import { AsyncLocalStorage } from "node:async_hooks";
import { performance as performance$1 } from "node:perf_hooks";
import { MessageChannel, MessagePort, getEnvironmentData, isMainThread, receiveMessageOnPort, setEnvironmentData, threadId } from "node:worker_threads";
import { realpath, stat } from "node:fs/promises";
import { parse } from "semver";
import "node:util";
import { sha256FileSync } from "@openclaw/fs-safe/durability";
import "node:util/types";
import { acquireFileLockSync } from "@openclaw/fs-safe/file-lock";
import { setImmediate } from "node:timers/promises";
import { probeTreeClone } from "@openclaw/fs-safe/copy";
import { InsertQueryNode, Kysely, SelectQueryNode, SqliteDialect, sql } from "kysely";
//#region src/config/version.ts
/** Parses stable, prerelease, and legacy dot-beta OpenClaw versions. */
function parseOpenClawVersion(raw) {
if (!raw) return null;
const normalized = normalizeLegacyDotBetaVersion(raw.trim());
return parse(normalized);
}
function compareOpenClawVersions(a, b) {
const parsedA = parseOpenClawVersion(a);
const parsedB = parseOpenClawVersion(b);
if (!parsedA || !parsedB) return null;
return compareOpenClawSemver(parsedA, parsedB);
}
//#endregion
//#region src/config/config-env-values.ts
function isBlockedConfigEnvVar(key) {
return key.toUpperCase() === "OPENCLAW_ALLOW_OLDER_BINARY_DESTRUCTIVE_ACTIONS" || key.toUpperCase() === "OPENCLAW_INCLUDE_ROOTS" || key.toUpperCase() === "OPENCLAW_CONFIG_READONLY" || isDangerousHostEnvVarName(key) || isDangerousHostEnvOverrideVarName(key);
}
/** Returns whether a config-controlled environment entry is safe to apply at runtime. */
function isConfigRuntimeEnvVarAllowed(key, value) {
return Boolean(value.trim()) && !isBlockedConfigEnvVar(key) && !containsEnvVarReference(value);
}
/** Collects config env vars safe to inject into runtime process environments. */
function collectConfigRuntimeEnvVars(cfg) {
const envConfig = cfg?.env;
if (!envConfig) return {};
const entries = {};
const candidates = [...Object.entries(envConfig.vars ?? {}), ...Object.entries(envConfig).filter(([key]) => key !== "shellEnv" && key !== "vars")];
for (const [rawKey, value] of candidates) {
if (typeof value !== "string" || !value.trim()) continue;
const key = normalizeEnvVarKey(rawKey, { portable: true });
if (!key) continue;
if (!isConfigRuntimeEnvVarAllowed(key, value)) continue;
entries[key] = value;
}
return entries;
}
function findCaseInsensitiveEnvKey(env, key) {
if (Object.hasOwn(env, key)) return key;
const upperKey = key.toUpperCase();
return Object.keys(env).find((candidate) => candidate.toUpperCase() === upperKey);
}
function envSnapshotKey(key) {
return process.platform === "win32" ? key.toUpperCase() : key;
}
function indexConfigRuntimeEnvValues(entries) {
const allowedValues = /* @__PURE__ */ new Map();
for (const [key, value] of Object.entries(entries)) for (const normalizedKey of resolveEnvNormalizationKeys(key)) {
const values = allowedValues.get(normalizedKey) ?? /* @__PURE__ */ new Set();
values.add(value);
allowedValues.set(normalizedKey, values);
}
return allowedValues;
}
//#endregion
//#region src/config/config-env-vars.ts
const appliedConfigEnvOwnership = /* @__PURE__ */ new WeakMap();
function resolveAppliedConfigEnvOwnership(env) {
return {
...appliedConfigEnvOwnership.get(env),
...env === process.env ? publishedConfigRuntimeEnvState.ownedEnv : {}
};
}
new AsyncLocalStorage();
function cloneEnvWithPlatformSemantics(env) {
const cloned = { ...env };
const ownedEnv = resolveAppliedConfigEnvOwnership(env);
if (process.platform !== "win32") {
appliedConfigEnvOwnership.set(cloned, ownedEnv);
return cloned;
}
const proxy = new Proxy(cloned, {
deleteProperty(target, property) {
if (typeof property !== "string") return Reflect.deleteProperty(target, property);
const key = findCaseInsensitiveEnvKey(target, property);
return key ? Reflect.deleteProperty(target, key) : true;
},
get(target, property, receiver) {
if (typeof property !== "string") return Reflect.get(target, property, receiver);
const key = findCaseInsensitiveEnvKey(target, property);
return key ? target[key] : Reflect.get(target, property, receiver);
},
getOwnPropertyDescriptor(target, property) {
if (typeof property !== "string") return Reflect.getOwnPropertyDescriptor(target, property);
const key = findCaseInsensitiveEnvKey(target, property);
if (!key) return;
return {
configurable: true,
enumerable: true,
value: target[key],
writable: true
};
},
has(target, property) {
return typeof property === "string" ? findCaseInsensitiveEnvKey(target, property) !== void 0 : Reflect.has(target, property);
},
set(target, property, value) {
if (typeof property !== "string") return Reflect.set(target, property, value);
target[findCaseInsensitiveEnvKey(target, property) ?? property] = value;
return true;
}
});
appliedConfigEnvOwnership.set(proxy, ownedEnv);
return proxy;
}
let publishedConfigRuntimeEnvState = {
generation: 0,
ownedEnv: {},
sourceConfig: null
};
function collectConfigRuntimeEnvOwnership(sourceConfig, before, after, options = {}) {
const ownedEnv = {};
const replacedLowerPrecedenceKeys = new Set((options.replacedLowerPrecedenceKeys ?? []).map(envSnapshotKey));
for (const [key, value] of Object.entries(collectConfigRuntimeEnvVars(sourceConfig))) for (const normalizedKey of resolveEnvNormalizationKeys(key)) {
const afterKey = findCaseInsensitiveEnvKey(after, normalizedKey);
if (!afterKey || after[afterKey] !== value) continue;
const beforeKey = findCaseInsensitiveEnvKey(before, normalizedKey);
if (beforeKey && before[beforeKey] === value && !replacedLowerPrecedenceKeys.has(envSnapshotKey(afterKey))) continue;
ownedEnv[afterKey] = value;
}
return ownedEnv;
}
function filterConfigRuntimeEnvOwnership(sourceConfig, env, ownedEnv) {
const allowedValues = indexConfigRuntimeEnvValues(collectConfigRuntimeEnvVars(sourceConfig));
const filtered = {};
for (const [key, value] of Object.entries(ownedEnv)) {
const normalizedKey = resolveEnvNormalizationKeys(key)[0] ?? key;
const actualKey = findCaseInsensitiveEnvKey(env, key);
if (actualKey && env[actualKey] === value && allowedValues.get(normalizedKey)?.has(value)) filtered[actualKey] = value;
}
return filtered;
}
/** Applies config env vars to an environment without overwriting existing non-empty values. */
function applyConfigEnvVars(cfg, env = process.env, options = {}) {
const before = { ...env };
const previousOwnedEnv = resolveAppliedConfigEnvOwnership(env);
const entries = collectConfigRuntimeEnvVars(cfg);
const lowerPrecedenceEntries = Object.entries(options.lowerPrecedenceEnv ?? {});
const lowerPrecedenceEnv = new Map(lowerPrecedenceEntries.map(([key, value]) => [envSnapshotKey(key), value]));
const configEnvKeys = expandEnvNormalizationKeys(Object.keys(entries));
const configValuesByKey = indexConfigRuntimeEnvValues(entries);
const higherPrecedenceValues = /* @__PURE__ */ new Map();
for (const key of Object.keys(entries)) {
const normalizedKeys = resolveEnvNormalizationKeys(key);
const winningValue = normalizedKeys.map((normalizedKey) => [normalizedKey, env[normalizedKey]]).find(([normalizedKey, currentValue]) => currentValue?.trim() && lowerPrecedenceEnv.get(normalizedKey) !== currentValue && !configValuesByKey.get(normalizedKey)?.has(currentValue))?.[1];
if (winningValue !== void 0) for (const normalizedKey of normalizedKeys) higherPrecedenceValues.set(normalizedKey, winningValue);
}
const replacedLowerPrecedenceKeys = [];
for (const [key, value] of lowerPrecedenceEntries) if (configEnvKeys.has(envSnapshotKey(key)) && env[key] === value) {
delete env[key];
replacedLowerPrecedenceKeys.push(key);
}
if (replacedLowerPrecedenceKeys.length > 0) options.onLowerPrecedenceKeysReplaced?.(replacedLowerPrecedenceKeys);
for (const [key, value] of Object.entries(entries)) {
const higherPrecedenceValue = higherPrecedenceValues.get(envSnapshotKey(key));
if (higherPrecedenceValue !== void 0) {
env[key] = higherPrecedenceValue;
continue;
}
const currentValue = env[key];
if (currentValue?.trim() && lowerPrecedenceEnv.get(envSnapshotKey(key)) !== currentValue) continue;
env[key] = value;
}
normalizeZaiEnv(env);
appliedConfigEnvOwnership.set(env, {
...filterConfigRuntimeEnvOwnership(cfg, env, previousOwnedEnv),
...collectConfigRuntimeEnvOwnership(cfg, before, env, { replacedLowerPrecedenceKeys })
});
}
//#endregion
//#region src/infra/sqlite-post-commit.ts
const pendingPublications = resolveGlobalSingleton(Symbol.for("openclaw.sqlitePostCommitPublications"), () => /* @__PURE__ */ new WeakMap());
const pendingTransactionState = resolveGlobalSingleton(Symbol.for("openclaw.sqliteTransactionState"), () => /* @__PURE__ */ new WeakMap());
/** Publications are non-throwing observers, never part of a durable transaction's result. */
function deferSqlitePostCommitPublication(db, publish) {
const pending = pendingPublications.get(db);
if (!pending) return false;
pending.push(publish);
return true;
}
/** A lost transaction invalidates every savepoint's staged state and observers. */
function discardSqliteTransactionState(db, error) {
pendingPublications.get(db)?.splice(0);
const rolledBackState = pendingTransactionState.get(db)?.splice(0) ?? [];
pendingPublications.delete(db);
pendingTransactionState.delete(db);
for (const state of rolledBackState.toReversed()) state.rollback(error);
}
/** Nested rollback restores staged state and discards observers; savepoints wait for outer commit. */
function withSqlitePostCommitPublications(db, transaction) {
const nested = db.isTransaction;
const publications = nested ? pendingPublications.get(db) : [];
const transactionState = nested ? pendingTransactionState.get(db) : [];
const publicationStart = publications?.length ?? 0;
const stateStart = transactionState?.length ?? 0;
if (!nested && publications && transactionState) {
pendingPublications.set(db, publications);
pendingTransactionState.set(db, transactionState);
}
let result;
try {
result = transaction();
} catch (error) {
publications?.splice(publicationStart);
const rolledBackState = transactionState?.splice(stateStart) ?? [];
for (const state of rolledBackState.toReversed()) state.rollback(error);
throw error;
} finally {
if (!nested) {
pendingPublications.delete(db);
pendingTransactionState.delete(db);
}
}
if (!nested) {
for (const state of transactionState ?? []) state.commit();
for (const state of transactionState ?? []) state.prepareObservers?.();
for (const publish of publications ?? []) publish();
}
return result;
}
//#endregion
//#region src/infra/sqlite-worker-identity.ts
/** Native SQLite namespaces are filesystem locators, not distinct database owners. */
function normalizeDatabasePath(location) {
const normalized = process.platform === "win32" ? normalizeWindowsPathPreservingCase(location) : location;
return process.platform === "win32" && !/^(?:[a-z]:[\\/]|[\\/]{2})/iu.test(normalized) ? location : normalized;
}
const useDatabaseBirthtime = process.platform !== "linux";
function databaseFileIdentityKey(file) {
return `${file.dev}:${file.ino}`;
}
function readDatabaseIdentityBirthtime(file) {
return useDatabaseBirthtime ? file.birthtimeNs.toString() : "0";
}
function existingIdentity(file, canonicalFile, canonicalPath) {
if (!file.isFile()) throw new Error("SQLite worker database path must identify a regular file");
if (file.dev !== canonicalFile.dev || file.ino !== canonicalFile.ino || readDatabaseIdentityBirthtime(file) !== readDatabaseIdentityBirthtime(canonicalFile)) throw new Error("SQLite database pathname changed during admission");
return {
key: `file:${databaseFileIdentityKey(file)}`,
canonicalPath: normalizeDatabasePath(canonicalPath),
birthtime: readDatabaseIdentityBirthtime(file)
};
}
/** In-process owner key only; never rewrite a configured or persisted database locator. */
function resolveDatabasePathKey(databasePath) {
const missing = [];
let ancestor = path.resolve(databasePath);
while (true) try {
return normalizeDatabasePath(path.join(realpathSync.native(ancestor), ...missing));
} catch (error) {
if (!hasErrnoCode(error, "ENOENT")) throw error;
missing.unshift(path.basename(ancestor));
const parent = path.dirname(ancestor);
if (parent === ancestor) throw error;
ancestor = parent;
}
}
/** Inspect a native-owner path without replacing its diagnostic for a non-file target. */
function inspectDatabasePathIdentitySync(databasePath) {
const resolvedPath = path.resolve(databasePath);
let file;
try {
file = statSync(resolvedPath, { bigint: true });
} catch (error) {
if (!hasErrnoCode(error, "ENOENT")) throw error;
}
if (file) {
if (!file.isFile()) return;
const canonicalPath = resolveDatabasePathKey(resolvedPath);
return existingIdentity(file, statSync(canonicalPath, { bigint: true }), canonicalPath);
}
const canonicalPath = resolveDatabasePathKey(resolvedPath);
return {
key: `path:${canonicalPath}`,
canonicalPath
};
}
/** Capture identity before yielding; worker admission requires a regular file or absent path. */
function readDatabasePathIdentitySync(databasePath) {
const identity = inspectDatabasePathIdentitySync(databasePath);
if (!identity) throw new Error("SQLite worker database path must identify a regular file");
return identity;
}
/** Inspect retained aliases only while binding a newly observed database path. */
function findChangedDatabasePaths(paths, observed) {
return [...paths].filter((pathname) => inspectDatabasePathIdentitySync(pathname)?.key !== observed.key);
}
async function readDatabasePathIdentity(databasePath) {
const file = await stat(databasePath, { bigint: true }).catch((error) => {
if (hasErrnoCode(error, "ENOENT")) return;
throw error;
});
if (file) try {
const canonicalPath = await realpath(databasePath);
return existingIdentity(file, await stat(canonicalPath, { bigint: true }), canonicalPath);
} catch (error) {
if (hasErrnoCode(error, "ENOENT")) throw new Error("SQLite database pathname changed during admission", { cause: error });
throw error;
}
const missing = [];
let ancestor = databasePath;
while (true) try {
const canonicalPath = normalizeDatabasePath(path.join(await realpath(ancestor), ...missing));
return {
key: `path:${canonicalPath}`,
canonicalPath
};
} catch (error) {
if (!hasErrnoCode(error, "ENOENT")) throw error;
missing.unshift(path.basename(ancestor));
const parent = path.dirname(ancestor);
if (parent === ancestor) throw error;
ancestor = parent;
}
}
function assertExistingDatabaseIdentity(databasePath, expected, expectedBirthtime) {
const file = statSync(databasePath, { bigint: true });
if (!file.isFile() || `file:${file.dev}:${file.ino}` !== expected || expectedBirthtime !== void 0 && readDatabaseIdentityBirthtime(file) !== expectedBirthtime) throw new Error("SQLite database file identity changed before existing-only open");
}
//#endregion
//#region src/infra/sqlite-lifecycle-errors.ts
var OpenClawStateOwnershipError = class extends Error {};
var OpenClawStateOwnershipMetadataError = class extends OpenClawStateOwnershipError {
constructor(databasePath, message) {
super(`OpenClaw shared state ownership metadata is invalid at ${databasePath}: ${message}. Repair it with OPENCLAW_SUPERVISOR_MODE=external openclaw database ownership claim --manager <manager-id>.`);
this.databasePath = databasePath;
this.name = "OpenClawStateOwnershipMetadataError";
}
};
var OpenClawStateExternalOwnershipError = class extends OpenClawStateOwnershipError {
constructor(databasePath, managerId) {
super(`OpenClaw shared state database ${databasePath} is externally supervised by ${managerId}. Use that external supervisor with OPENCLAW_SUPERVISOR_MODE=external for writable operations.`);
this.databasePath = databasePath;
this.managerId = managerId;
this.name = "OpenClawStateExternalOwnershipError";
}
};
const SqliteCoordinatorError = resolveGlobalSingleton(Symbol.for("openclaw.sqliteCoordinatorError"), () => class CoordinatorError extends Error {
constructor(message, cause) {
super(message);
this.cause = cause;
this.name = "SqliteCoordinatorError";
}
});
function createSqliteLifecycleAggregateError(errors, message, cause) {
return new AggregateError(errors, message, { cause });
}
/** Keep the first failure as the cause while retaining independent cleanup errors. */
function throwSqliteLifecycleErrors(errors, message) {
if (errors.length === 1) throw errors[0];
if (errors.length > 1) throw createSqliteLifecycleAggregateError(errors, message, errors[0]);
}
/** Settle a synchronous SQLite operation and preserve both operation and cleanup failures. */
function runWithSqliteCleanup(resource, operationLabel, operation) {
let result;
try {
result = operation();
if (isPromiseLike(result)) throw new SqliteCoordinatorError(`${operationLabel} must remain synchronous`);
} catch (operationError) {
try {
resource.release();
} catch (releaseError) {
throw createSqliteLifecycleAggregateError([operationError, releaseError], `${operationLabel} and resource release both failed`, operationError);
}
throw operationError;
}
try {
resource.release();
} catch (releaseError) {
throw new SqliteCoordinatorError(`${operationLabel} completed, but releasing its resource failed`, releaseError);
}
return result;
}
//#endregion
//#region src/state/openclaw-state-db-async-lifecycle.ts
const STATE_DATABASE_READ_ADMISSION_INVALIDATED = "STATE_DATABASE_READ_ADMISSION_INVALIDATED";
var StateDatabaseReadAdmissionInvalidatedError = class extends Error {
constructor(..._args) {
super(..._args);
this.code = STATE_DATABASE_READ_ADMISSION_INVALIDATED;
}
};
function isStateDatabaseReadAdmissionInvalidatedError(error) {
return extractErrorCode(error) === STATE_DATABASE_READ_ADMISSION_INVALIDATED;
}
const maintenanceResources = resolveGlobalSingleton(Symbol.for("openclaw.databaseMaintenanceResources"), () => ({
current: new AsyncLocalStorage(),
claims: /* @__PURE__ */ new WeakMap(),
parents: /* @__PURE__ */ new WeakMap()
}));
function getOpenClawDatabaseMaintenanceScope() {
return maintenanceResources.current.getStore()?.scope;
}
function isOpenClawDatabaseMaintenanceResourceOwned(resource, scope) {
return maintenanceResources.claims.get(resource)?.scope === scope;
}
function getOpenClawDatabaseMaintenanceResourceScope(resource) {
return maintenanceResources.claims.get(resource)?.scope;
}
function runMaintenance(scope, operation) {
const accepted = {
scope,
active: true
};
try {
const result = maintenanceResources.current.run(accepted, operation);
if (result instanceof Promise) {
const settled = () => {
accepted.active = false;
};
result.then(settled, settled);
scope.track(result);
} else accepted.active = false;
return result;
} catch (error) {
accepted.active = false;
throw error;
}
}
/** Retain one exact resource claim for finite commands while its maintenance scope drains. */
function captureOpenClawDatabaseMaintenanceResource(resource, expectedScope) {
const claim = maintenanceResources.claims.get(resource);
const assertCurrent = () => {
expectedScope.assertOwnerCurrent();
if (claim?.scope !== expectedScope || maintenanceResources.claims.get(resource) !== claim) throw new Error("Database maintenance resource owner changed");
};
assertCurrent();
return {
assertCurrent,
async run(operation) {
assertCurrent();
return runMaintenance(expectedScope, operation);
}
};
}
/** A cached handle used by an independent caller remains with the ordinary cache owner. */
function observeOpenClawDatabaseMaintenanceResource(resource) {
if (!resource) return;
const claim = maintenanceResources.claims.get(resource);
const current = getOpenClawDatabaseMaintenanceScope();
if (!claim) return;
const owner = commonMaintenanceAncestor(claim.scope, current);
if (owner === claim.scope) return;
claim.scope.assertAdmission();
claim.release();
maintenanceResources.claims.delete(resource);
if (owner) owner.own(resource, claim.phase, claim.close);
}
function commonMaintenanceAncestor(owner, scope) {
const ancestors = /* @__PURE__ */ new Set();
for (let current = owner; current; current = maintenanceResources.parents.get(current)) ancestors.add(current);
for (let current = scope; current; current = maintenanceResources.parents.get(current)) if (ancestors.has(current)) return current;
}
/** The cache owns physical identity and admission across drainage and file exclusion. */
function createOpenClawStateDatabaseAsyncLifecycle() {
const resources = /* @__PURE__ */ new Set();
const records = /* @__PURE__ */ new Map();
const recordsByPath = /* @__PURE__ */ new Map();
const seals = /* @__PURE__ */ new Set();
const attempts = /* @__PURE__ */ new Map();
let tail = Promise.resolve();
const known = (pathname) => recordsByPath.get(pathname) ?? recordsByPath.get(path.resolve(pathname));
const bindPath = (record, pathname) => {
record.paths.add(pathname);
if (!recordsByPath.has(pathname)) recordsByPath.set(pathname, record);
};
const overlaps = (left, right) => {
if (left.identity.key === right.identity.key) return true;
for (const pathname of left.paths) if (right.paths.has(pathname)) return true;
return false;
};
const isSealed = (record) => {
if (seals.size === 0) return false;
for (const held of seals) if (held.record === void 0 || overlaps(held.record, record)) return true;
return false;
};
const hasCloseCustody = (record) => isSealed(record) || attempts.has(record);
const assertOpen = (record) => {
if (isSealed(record)) throw new StateDatabaseReadAdmissionInvalidatedError("OpenClaw state database read admission is closed");
};
const findPhysicalRecord = (identity) => {
const record = records.get(identity.key);
if (!record || !identity.key.startsWith("file:") || hasCloseCustody(record)) return record;
for (const pathname of findChangedDatabasePaths(record.paths, identity)) {
record.admissions.delete(pathname);
record.paths.delete(pathname);
if (recordsByPath.get(pathname) === record) recordsByPath.delete(pathname);
}
if (record.paths.size > 0) {
if (!record.paths.has(record.identity.canonicalPath)) record.identity = identity;
return record;
}
invalidate(record);
forget(record);
};
const resolve = (resolvedPath, preparedIdentity) => {
const cached = recordsByPath.get(resolvedPath);
if (cached && (!preparedIdentity || cached.identity.key === preparedIdentity.key)) return !preparedIdentity && cached.identity.key.startsWith("path:") ? resolve(resolvedPath, readDatabasePathIdentitySync(resolvedPath)) : cached;
const identity = preparedIdentity ?? readDatabasePathIdentitySync(resolvedPath);
let record = findPhysicalRecord(identity);
if (!record && identity.key.startsWith("file:")) {
record = [...records.values()].find((candidate) => {
if (!candidate.identity.key.startsWith("path:")) return false;
try {
return readDatabasePathIdentitySync(candidate.identity.canonicalPath).key === identity.key;
} catch {
return false;
}
});
if (record) {
records.delete(record.identity.key);
record.identity = identity;
records.set(identity.key, record);
}
}
if (!record) {
record = {
coordinationKey: identity.key,
identity,
paths: /* @__PURE__ */ new Set(),
generation: {},
admissions: /* @__PURE__ */ new Map()
};
records.set(identity.key, record);
}
bindPath(record, resolvedPath);
bindPath(record, identity.canonicalPath);
return record;
};
const resolveForNative = (pathname) => {
const resolvedPath = path.resolve(pathname);
const cached = recordsByPath.get(resolvedPath);
if (cached) return cached;
const identity = inspectDatabasePathIdentitySync(resolvedPath);
return identity ? resolve(resolvedPath, identity) : void 0;
};
const invalidate = (record) => {
for (const current of record ? [record] : records.values()) {
current.generation = {};
current.admissions.clear();
}
};
const seal = (record) => {
invalidate(record);
const held = { record };
seals.add(held);
return held;
};
const release = (attempt) => {
if (attempt.seal) {
seals.delete(attempt.seal);
attempt.seal = void 0;
}
};
const forget = (record) => {
if (!hasCloseCustody(record) && records.get(record.identity.key) === record) {
records.delete(record.identity.key);
for (const pathname of record.paths) if (recordsByPath.get(pathname) === record) {
recordsByPath.delete(pathname);
for (const replacement of records.values()) if (replacement.paths.has(pathname)) {
recordsByPath.set(pathname, replacement);
break;
}
}
}
};
const captureRecord = (record, databasePath) => {
const previous = record.admissions.get(databasePath);
if (previous) return previous;
const generation = record.generation;
const admission = Object.freeze({
databasePath,
coordinationKey: record.coordinationKey,
get identity() {
return record.identity;
},
assertCurrent() {
assertOpen(record);
if (records.get(record.identity.key) !== record || record.generation !== generation || record.admissions.get(databasePath) !== admission) throw new StateDatabaseReadAdmissionInvalidatedError("OpenClaw state database read admission changed");
}
});
record.admissions.set(databasePath, admission);
return admission;
};
const captureResolved = (databasePath) => {
const record = resolve(databasePath);
assertOpen(record);
return captureRecord(record, databasePath);
};
return {
identity(pathname) {
return known(pathname)?.identity ?? inspectDatabasePathIdentitySync(pathname);
},
knownIdentity(pathname) {
return known(pathname)?.identity;
},
publish(pathname) {
const resolvedPath = path.resolve(pathname);
const identity = readDatabasePathIdentitySync(resolvedPath);
const previous = recordsByPath.get(resolvedPath);
let record = findPhysicalRecord(identity);
if (previous && previous.identity.key !== identity.key) {
if (previous.identity.key.startsWith("path:") && !record) {
records.delete(previous.identity.key);
previous.identity = identity;
records.set(identity.key, previous);
record = previous;
} else {
const failed = attempts.get(previous);
if (failed) {
failed.superseded = true;
failed.seal ??= seal(previous);
} else invalidate(previous);
forget(previous);
}
}
if (!record) record = resolve(resolvedPath, identity);
bindPath(record, resolvedPath);
bindPath(record, identity.canonicalPath);
return {
identity,
admission: captureRecord(record, resolvedPath)
};
},
invalidate(pathname) {
if (pathname === void 0) invalidate();
else {
const record = known(pathname);
if (record) invalidate(record);
}
},
register(resource) {
resources.add(resource);
for (const attempt of attempts.values()) attempt.queue?.add(resource);
return () => {
resources.delete(resource);
};
},
capture(pathname) {
const cached = recordsByPath.get(pathname);
const retained = cached?.admissions.get(pathname);
if (cached && retained && cached.identity.key.startsWith("file:")) {
retained.assertCurrent();
return retained;
}
return captureResolved(path.resolve(pathname));
},
holdExclusion(pathname) {
const record = resolve(path.resolve(pathname));
const held = seal(record);
return () => {
seals.delete(held);
for (const current of records.values()) if (overlaps(record, current)) forget(current);
};
},
close(pathname, retireNative) {
const record = pathname === void 0 ? void 0 : resolveForNative(pathname);
if (pathname !== void 0 && !record) return Promise.resolve(retireNative());
let attempt = attempts.get(record);
if (attempt?.pending) return attempt.pending;
if (!attempt) {
attempt = { retained: /* @__PURE__ */ new Set() };
attempts.set(record, attempt);
}
attempt.seal ??= seal(record);
const current = attempt;
const pending = tail.then(async () => {
const closing = /* @__PURE__ */ new Set([...resources, ...current.retained]);
for (const entry of attempts.values()) for (const resource of entry.retained) closing.add(resource);
current.queue = closing;
const errors = [];
while (current.queue.size) {
const ordinary = [...current.queue].filter((resource) => resource.phase !== "after-resources");
if (!ordinary.length && errors.length) {
for (const resource of current.queue) current.retained.add(resource);
break;
}
const batch = ordinary.length ? ordinary : [...current.queue];
for (const resource of batch) current.queue.delete(resource);
await Promise.all(batch.map(async (resource) => {
try {
await resource.close(record?.identity);
current.retained.delete(resource);
} catch (error) {
current.retained.add(resource);
errors.push(error);
}
}));
}
if (errors.length && !current.superseded) release(current);
throwSqliteLifecycleErrors(errors, "OpenClaw state resource drainage failed");
const retired = retireNative(record?.identity);
attempts.delete(record);
release(current);
if (record === void 0) {
for (const [key, entry] of attempts) if (!entry.pending) {
attempts.delete(key);
release(entry);
}
for (const entry of records.values()) forget(entry);
} else forget(record);
return retired;
}).finally(() => {
current.queue = void 0;
});
current.pending = pending;
tail = pending.then(() => void 0, () => void 0);
pending.catch(() => {
current.pending = void 0;
});
return pending;
}
};
}
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/util.js
function getEnumValues(entries) {
const numericValues = Object.values(entries).filter((v) => typeof v === "number");
return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
}
function joinValues(array, separator = "|") {
return array.map((val) => stringifyPrimitive(val)).join(separator);
}
function jsonStringifyReplacer(_, value) {
if (typeof value === "bigint") return value.toString();
return value;
}
var Cached = class {
constructor(getter) {
this._getter = getter;
this._value = void 0;
}
get value() {
const getter = this._getter;
if (getter !== void 0) {
this._value = getter();
this._getter = void 0;
}
return this._value;
}
};
function cached(getter) {
return new Cached(getter);
}
function nullish(input) {
return input === null || input === void 0;
}
function cleanRegex(source) {
const start = source.startsWith("^") ? 1 : 0;
const end = source.endsWith("$") ? source.length - 1 : source.length;
return source.slice(start, end);
}
function floatSafeRemainder(val, step) {
const ratio = val / step;
const roundedRatio = Math.round(ratio);
const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
if (Math.abs(ratio - roundedRatio) < tolerance) return 0;
return ratio - roundedRatio;
}
function assignProp(target, prop, value) {
Object.defineProperty(target, prop, {
value,
writable: true,
enumerable: true,
configurable: true
});
}
/**
* Whichever object a def's `shape` currently answers from: the one the caller passed until the first read, the frozen copy after it.
*
* Its keys and descriptors read without invoking anything, which is what lets a discriminated union check its discriminator, and the cycle walk read a shape, without resolving a getter that references the schema being constructed. A def that answers `shape` from an accessor of its own has none.
*/
function rawShape(def) {
const desc = Object.getOwnPropertyDescriptor(def, "shape");
return desc?.get ? desc.get.raw : desc?.value;
}
function sourceShape(schema) {
return rawShape(schema._zod.def) ?? schema._zod.def.shape;
}
function deferProp(target, key, getter) {
Object.defineProperty(target, key, {
get() {
const value = getter();
assignProp(this, key, value);
return value;
},
enumerable: true,
configurable: true
});
}
function putProp(target, key, value) {
if (key in target) assignProp(target, key, value);
else target[key] = value;
}
/**
* Copies `keys` of `source`'s shape onto `target`, each value passed through `wrap`.
*
* A key the source has resolved is copied through now, so the derived shape states it outright and nothing has to resolve it to learn what it holds. A key the source still defers stays deferred, and reads back through the source's own `shape`, so it resolves once and both shapes get that one schema.
*/
function mirrorShape(target, source, keys, wrap) {
const raw = sourceShape(source);
for (const key of keys) {
const desc = Object.getOwnPropertyDescriptor(raw, key);
if (!desc.enumerable) continue;
if (desc.get) deferProp(target, key, () => {
const value = source._zod.def.shape[key];
return wrap ? wrap(value, key) : value;
});
else putProp(target, key, wrap ? wrap(desc.value, key) : desc.value);
}
}
function mirrorProps(target, source) {
for (const key of Reflect.ownKeys(source)) {
const desc = Object.getOwnPropertyDescriptor(source, key);
if (!desc.enumerable) continue;
if (desc.get) deferProp(target, key, () => source[key]);
else putProp(target, key, desc.value);
}
}
function mergeDefs(...defs) {
const mergedDescriptors = {};
for (const def of defs) {
const descriptors = Object.getOwnPropertyDescriptors(def);
Object.assign(mergedDescriptors, descriptors);
}
return Object.defineProperties({}, mergedDescriptors);
}
function esc(str) {
return JSON.stringify(str);
}
function slugify(input) {
return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
}
const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
function isObject(data) {
return typeof data === "object" && data !== null && !Array.isArray(data);
}
const allowsEval = /* @__PURE__*/ cached(() => {
if (globalConfig.jitless) return false;
if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) return false;
try {
new Function("");
return true;
} catch (_) {
return false;
}
});
function isPlainObject(o) {
if (isObject(o) === false) return false;
const ctor = o.constructor;
if (ctor === void 0) return true;
if (typeof ctor !== "function") return true;
const prot = ctor.prototype;
if (isObject(prot) === false) return false;
if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) return false;
return true;
}
function shallowClone(o) {
if (isPlainObject(o)) return { ...o };
if (Array.isArray(o)) return [...o];
if (o instanceof Map) return new Map(o);
if (o instanceof Set) return new Set(o);
return o;
}
const propertyKeyTypes = /* @__PURE__*/ new Set([
"string",
"number",
"symbol"
]);
function escapeRegex(str) {
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
function clone(inst, def, params) {
const cl = new inst._zod.constr(def ?? inst._zod.def);
if (!def || params?.parent) cl._zod.parent = inst;
return cl;
}
function normalizeParams(_params) {
const params = _params;
if (!params) return {};
if (typeof params === "string") return { error: () => params };
if (params?.message !== void 0) {
if (params?.error !== void 0) throw new Error("Cannot specify both `message` and `error` params");
params.error = params.message;
}
delete params.message;
if (typeof params.error === "string") return {
...params,
error: () => params.error
};
return params;
}
function stringifyPrimitive(value) {
if (typeof value === "bigint") return value.toString() + "n";
if (typeof value === "string") return `"${value}"`;
return `${value}`;
}
function optionalKeys(shape) {
return Object.keys(shape).filter((k) => {
return shape[k]._zod.optin !== void 0 && shape[k]._zod.optout === "optional";
});
}
const NUMBER_FORMAT_RANGES = /*@__PURE__*/ (() => ({
safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
int32: [-2147483648, 2147483647],
uint32: [0, 4294967295],
float32: [-34028234663852886e22, 34028234663852886e22],
float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
}))();
const BIGINT_FORMAT_RANGES = {
int64: [/* @__PURE__*/ BigInt("-9223372036854775808"), /* @__PURE__*/ BigInt("9223372036854775807")],
uint64: [/* @__PURE__*/ BigInt(0), /* @__PURE__*/ BigInt("18446744073709551615")]
};
function pick(schema, mask) {
const currDef = schema._zod.def;
const checks = currDef.checks;
if (checks && checks.length > 0) throw new Error(".pick() cannot be used on object schemas containing refinements");
const newShape = {};
mirrorShape(newShape, schema, maskedKeys(schema, mask));
return clone(schema, mergeDefs(currDef, {
shape: newShape,
checks: []
}));
}
function maskedKeys(schema, mask) {
const raw = sourceShape(schema);
const keys = [];
for (const key of Reflect.ownKeys(mask)) {
if (!Object.getOwnPropertyDescriptor(raw, key)?.enumerable) throw new Error(`Unrecognized key: "${String(key)}"`);
if (mask[key]) keys.push(key);
}
return keys;
}
function omit(schema, mask) {
const currDef = schema._zod.def;
const checks = currDef.checks;
if (checks && checks.length > 0) throw new Error(".omit() cannot be used on object schemas containing refinements");
const omitted = new Set(maskedKeys(schema, mask));
const newShape = {};
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)).filter((key) => !omitted.has(key)));
return clone(schema, mergeDefs(currDef, {
shape: newShape,
checks: []
}));
}
function extend(schema, shape) {
if (!isPlainObject(shape)) throw new Error("Invalid input to extend: expected a plain object");
const checks = schema._zod.def.checks;
if (checks && checks.length > 0) {
const existingShape = sourceShape(schema);
for (const key of Reflect.ownKeys(shape)) if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
}
return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));
}
function extended(schema, shape) {
const newShape = {};
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)));
mirrorProps(newShape, shape);
return newShape;
}
function safeExtend(schema, shape) {
if (!isPlainObject(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));
}
function merge(a, b) {
if (!b?._zod?.def) throw new Error("Invalid input to merge: expected an object schema. To merge a plain shape, use `.extend()`.");
if (a._zod.def.checks?.length) throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
const newShape = {};
mirrorShape(newShape, a, Reflect.ownKeys(sourceShape(a)));
mirrorShape(newShape, b, Reflect.ownKeys(sourceShape(b)));
return clone(a, mergeDefs(a._zod.def, {
shape: newShape,
get catchall() {
return b._zod.def.catchall;
},
checks: b._zod.def.checks ?? []
}));
}
function partial(Class, schema, mask, name = "partial") {
const checks = schema._zod.def.checks;
if (checks && checks.length > 0) throw new Error(`.${name}() cannot be used on object schemas containing refinements`);
const selected = mask ? new Set(maskedKeys(schema, mask)) : void 0;
const newShape = {};
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), Class && ((value, key) => selected && !selected.has(key) ? value : new Class({
type: "optional",
innerType: value
})));
return clone(schema, mergeDefs(schema._zod.def, {
shape: newShape,
checks: []
}));
}
function required(Class, schema, mask) {
const selected = mask ? new Set(maskedKeys(schema, mask)) : void 0;
const newShape = {};
mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), (value, key) => selected && !selected.has(key) ? value : new Class({
type: "nonoptional",
innerType: value
}));
return clone(schema, mergeDefs(schema._zod.def, { shape: newShape }));
}
function aborted(x, startIndex = 0) {
if (x.aborted === true) return true;
for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue !== true) return true;
return false;
}
function explicitlyAborted(x, startIndex = 0) {
if (x.aborted === true) return true;
for (let i = startIndex; i < x.issues.length; i++) if (x.issues[i]?.continue === false) return true;
return false;
}
function prefixIssues(path, issues) {
return issues.map((iss) => {
var _a;
(_a = iss).path ?? (_a.path = []);
iss.path.unshift(path);
return iss;
});
}
function unwrapMessage(message) {
return typeof message === "string" ? message : message?.message;
}
function attachSchema(issues, start, inst) {
var _a;
for (let i = start; i < issues.length; i++) (_a = issues[i]).schema ?? (_a.schema = inst);
}
function finalizeIssue(iss, ctx, config) {
var _a;
const traits = iss.inst?._zod?.traits;
if (traits?.has("$ZodType")) {
if (traits.has("$ZodCheck")) (_a = iss).schema ?? (_a.schema = iss.inst);
else iss.schema = iss.inst;
}
const schemaError = iss.schema !== iss.inst ? iss.schema?._zod.def?.error : void 0;
const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(schemaError?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
const full = {};
for (const k of Object.keys(iss)) {
if (k === "inst" || k === "schema" || k === "continue" || k === "input" || k === "__proto__") continue;
full[k] = iss[k];
}
full.path ?? (full.path = []);
full.message = message;
if (ctx?.reportInput) full.input = iss.input;
return full;
}
const highSurrogate = /[\uD800-\uDBFF]/;
function codePointLength(str) {
const units = str.length;
if (!highSurrogate.test(str)) return units;
let count = units;
for (let i = 0; i < units - 1; i++) if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
count--;
i++;
}
return count;
}
function getLengthableOrigin(input) {
if (Array.isArray(input)) return "array";
if (typeof input === "string") return "string";
return "unknown";
}
function parsedType(data) {
const t = typeof data;
switch (t) {
case "number": return Number.isNaN(data) ? "nan" : "number";
case "object": {
if (data === null) return "null";
if (Array.isArray(data)) return "array";
const obj = data;
if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) return obj.constructor.name;
}
}
return t;
}
function issue(...args) {
const [iss, input, inst] = args;
if (typeof iss === "string") return {
message: iss,
code: "custom",
input,
inst
};
return { ...iss };
}
/**
* Installs a trait's members on its prototype. Each value builds that member for the instance on first read; the built value shadows the accessor as an own property, so a detached `const { parse } = schema` keeps working.
*
* Call this from a `proto` initializer, which runs once per prototype — never per instance.
*/
function members(proto, table) {
for (const key in table) {
const desc = Object.getOwnPropertyDescriptor(table, key);
if (desc.get) Object.defineProperty(proto, key, {
...desc,
enumerable: false
});
else defineBound(proto, key, desc.value);
}
}
/** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */
function own(inst, key, value, enumerable = true) {
Object.defineProperty(inst, key, {
configurable: true,
writable: true,
enumerable,
value
});
return value;
}
/** Like {@link own}, for a member that was never an own data property and has to stay out of `Object.keys`. */
function hide(inst, key, value) {
return own(inst, key, value, false);
}
/** Adds members a table derives from the instance: each builds on first read and shadows as own data, and assignment shadows the same way, as when these were own properties. */
function derived(computes, table) {
for (const key in computes) {
const compute = computes[key];
Object.defineProperty(table, key, {
configurable: true,
enumerable: true,
get() {
return own(this, key, compute(this));
},
set(value) {
own(this, key, value);
}
});
}
return table;
}
function defineBound(proto, key, fn) {
Object.defineProperty(proto, key, {
configurable: true,
get() {
return this == null ? fn : own(this, key, fn.bind(this));
},
set(value) {
own(this, key, value);
}
});
}
/** Returns the prototype to install on, or `undefined` if this group is already installed on it. */
function claim(inst, sentinel) {
const proto = Object.getPrototypeOf(inst);
return sentinel in proto ? void 0 : proto;
}
let installing;
let broke = false;
const breaker = {
configurable: true,
get() {
broke = true;
}
};
/**
* Installs a lazily-derived internal on the `_zod` prototype of `inst`'s
* constructor, computed from the internals object itself and cached there on
* first read. One accessor per constructor rather than one per instance.
*/
function defineLazyInternal(inst, key, compute) {
const proto = Object.getPrototypeOf(inst._zod);
if (key in proto && installing !== inst._zod) {
installing = void 0;
return;
}
installing = inst._zod;
Object.defineProperty(proto, key, {
configurable: true,
get() {
Object.defineProperty(this, key, breaker);
const outer = broke;
broke = false;
try {
const value = compute(this);
if (broke) delete this[key];
else Object.defineProperty(this, key, {
configurable: true,
writable: true,
value
});
broke = broke || outer;
return value;
} catch (err) {
delete this[key];
broke = broke || outer;
throw err;
}
},
set(value) {
Object.defineProperty(this, key, {
configurable: true,
writable: true,
value
});
}
});
}
/**
* Installs `key` on `inst`'s prototype, computed by `make` on first read and cached there as an own
* data property. One accessor per constructor rather than one per instance, because an own accessor
* puts every instance after the first into v8 dictionary mode. The key doubles as the sentinel.
*/
function installLazyProp(inst, key, make, enumerable) {
const proto = claim(inst, key);
if (!proto) return;
Object.defineProperty(proto, key, {
configurable: true,
get() {
const desc = {
configurable: true,
writable: true,
enumerable,
value: void 0
};
Object.defineProperty(this, key, desc);
desc.value = make(this);
Object.defineProperty(this, key, desc);
return desc.value;
},
set(value) {
Object.defineProperty(this, key, {
configurable: true,
writable: true,
enumerable,
value
});
}
});
}
/** Marks the thunk `_catch` synthesises for a constant catch value. `Function.length` cannot tell that thunk from a user callback — rest and defaulted parameters both report arity 0 — and a user callback reads `ctx.error`, whose issues only finalize correctly against the caller's per-parse error map. Provenance can say what arity cannot. A plain string key rather than `Symbol.for`, whose call at module scope no bundler can prove pure — the same shape that anchored `urlCanParse` into every build. */
const CONSTANT_CATCH = "~constantCatch";
/** Wraps a constant catch value in a thunk tagged with {@link CONSTANT_CATCH}. */
function constantCatch(value) {
const fn = () => value;
fn[CONSTANT_CATCH] = true;
return fn;
}
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/core.js
var _a$1;
const _zodDesc = {
value: void 0,
enumerable: false
};
let _E = "captureStackTrace" in Error ? Error : null;
function newError(Definition) {
const E = _E;
if (E) {
const saved = E.stackTraceLimit;
if (typeof saved === "number") {
try {
E.stackTraceLimit = 0;
} catch {
_E = null;
return new Definition();
}
try {
return new Definition();
} finally {
E.stackTraceLimit = saved;
}
}
}
return new Definition();
}
function $constructor(name, initializer, proto, params) {
const zodProto = {};
function Internals(def) {
this.def = def;
this.constr = _;
this.traits = /* @__PURE__ */ new Set();
}
Internals.prototype = zodProto;
const protoMembers = proto;
const initialized = protoMembers && /* @__PURE__ */ new WeakSet();
function init(inst, def) {
if (!inst._zod) {
_zodDesc.value = new Internals(def);
try {
Object.defineProperty(inst, "_zod", _zodDesc);
} finally {
_zodDesc.value = void 0;
}
} else if (inst._zod.traits.has(name)) return;
inst._zod.traits.add(name);
initializer(inst, def);
if (initialized) {
const own = Object.getPrototypeOf(inst);
const ctorProto = inst._zod.constr.prototype;
let up = own;
while (up && up !== ctorProto) up = Object.getPrototypeOf(up);
const target = up ?? own;
if (!initialized.has(target)) {
initialized.add(target);
members(target, protoMembers);
}
}
const proto = _.prototype;
for (const k in proto) {
if (!Object.prototype.hasOwnProperty.call(proto, k)) continue;
if (!(k in inst)) inst[k] = proto[k].bind(inst);
}
}
const Parent = params?.Parent ?? Object;
class Definition extends Parent {}
Object.defineProperty(Definition, "name", { value: name });
function _(def) {
const inst = params?.Parent ? newError(Definition) : this;
init(inst, def);
const deferred = inst._zod.deferred;
if (deferred) {
for (const fn of deferred) fn();
inst._zod.deferred = void 0;
}
const pp = globalThis.__zod_globalConfig?.postProcessor;
if (pp) pp(inst);
return inst;
}
Object.defineProperty(_, "init", { value: init });
Object.defineProperty(_, Symbol.hasInstance, { value: (inst) => {
if (params?.Parent && inst instanceof params.Parent) return true;
return inst?._zod?.traits?.has(name);
} });
Object.defineProperty(_, "name", { value: name });
return _;
}
var $ZodAsyncError = class extends Error {
constructor() {
super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
}
};
var $ZodEncodeError = class extends Error {
constructor(name) {
super(`Encountered unidirectional transform during encode: ${name}`);
this.name = "ZodEncodeError";
}
};
(_a$1 = globalThis).__zod_globalConfig ?? (_a$1.__zod_globalConfig = {});
const globalConfig = globalThis.__zod_globalConfig;
function config(newConfig) {
if (newConfig) Object.assign(globalConfig, newConfig);
return globalConfig;
}
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/errors.js
function _getMessage() {
const internals = this._zod;
internals.message ?? (internals.message = JSON.stringify(internals.def, jsonStringifyReplacer, 2));
return internals.message;
}
function _setMessage(value) {
this._zod.message = value;
}
const _messageDesc = {
get: _getMessage,
set: _setMessage,
enumerable: true,
configurable: true
};
const _issuesDesc = {
value: void 0,
enumerable: false
};
const _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
const initializer$1 = (inst, def) => {
inst.name = "$ZodError";
_issuesDesc.value = def;
Object.defineProperty(inst, "issues", _issuesDesc);
_issuesDesc.value = void 0;
Object.defineProperty(inst, "message", _messageDesc);
const proto = Object.getPrototypeOf(inst);
if (!_installedToString.has(proto)) {
_installedToString.add(proto);
Object.defineProperty(proto, "toString", {
configurable: true,
enumerable: false,
get() {
const value = () => this.message;
Object.defineProperty(this, "toString", {
value,
configurable: true,
writable: true
});
return value;
},
set(value) {
Object.defineProperty(this, "toString", {
value,
configurable: true,
writable: true
});
}
});
}
};
const $ZodError = $constructor("$ZodError", initializer$1);
$constructor("$ZodError", initializer$1, void 0, { Parent: Error });
/** Get-or-create `obj[key]` as an own data property. A path segment naming an inherited member
* ("toString", "constructor") would otherwise read through to the prototype, and assigning
* "__proto__" would hit the setter instead of creating a key. */
function node(obj, key, make) {
if (!Object.prototype.hasOwnProperty.call(obj, key)) {
if (key === "__proto__") Object.defineProperty(obj, key, {
value: make(),
writable: true,
enumerable: true,
configurable: true
});
else obj[key] = make();
}
return obj[key];
}
function flattenError(error, mapper = (issue) => issue.message) {
const fieldErrors = {};
const formErrors = [];
for (const sub of error.issues) if (sub.path.length > 0) node(fieldErrors, sub.path[0], () => []).push(mapper(sub));
else formErrors.push(mapper(sub));
return {
formErrors,
fieldErrors
};
}
function formatError(error, mapper = (issue) => issue.message) {
const fieldErrors = { _errors: [] };
const processError = (error, path = []) => {
for (const issue of error.issues) if (issue.code === "invalid_union" && issue.errors.length) issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
else if (issue.code === "invalid_key") processError({ issues: issue.issues }, [...path, ...issue.path]);
else if (issue.code === "invalid_element") processError({ issues: issue.issues }, [...path, ...issue.path]);
else {
const fullpath = [...path, ...issue.path];
if (fullpath.length === 0) fieldErrors._errors.push(mapper(issue));
else {
let curr = fieldErrors;
let i = 0;
while (i < fullpath.length) {
const el = fullpath[i];
const terminal = i === fullpath.length - 1;
if (el === "_errors") {
if (terminal) curr._errors.push(mapper(issue));
i++;
continue;
}
if (!Object.prototype.hasOwnProperty.call(curr, el)) Object.defineProperty(curr, el, {
value: { _errors: [] },
enumerable: true,
writable: true,
configurable: true
});
const node = curr[el];
if (terminal) node._errors.push(mapper(issue));
curr = node;
i++;
}
}
}
};
processError(error);
return fieldErrors;
}
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/parse.js
function finalizeParams(callee, params) {
return {
callee: params?.callee ?? callee,
Err: params?.Err
};
}
const _parse = (_Err) => {
const fn = (schema, value, _ctx, _params) => {
const ctx = _ctx ? {
..._ctx,
async: false
} : { async: false };
const result = schema._zod.run({
value,
issues: []
}, ctx);
if (result instanceof Promise) throw new $ZodAsyncError();
if (result.issues.length) {
const e = new ((_params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
captureStackTrace(e, _params?.callee ?? fn);
throw e;
}
return result.value;
};
return fn;
};
const _parseAsync = (_Err) => {
const fn = async (schema, value, _ctx, params) => {
const ctx = _ctx ? {
..._ctx,
async: true
} : { async: true };
let result = schema._zod.run({
value,
issues: []
}, ctx);
if (result instanceof Promise) result = await result;
if (result.issues.length) {
const e = new ((params?.Err) ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
captureStackTrace(e, params?.callee ?? fn);
throw e;
}
return result.value;
};
return fn;
};
const _safeParse = (_Err) => (schema, value, _ctx) => {
const ctx = _ctx ? {
..._ctx,
async: false
} : { async: false };
const result = schema._zod.run({
value,
issues: []
}, ctx);
if (result instanceof Promise) throw new $ZodAsyncError();
return result.issues.length ? failure(_Err, result.issues, ctx) : {
success: true,
data: result.value
};
};
function failure(Err, issues, ctx) {
let error;
return {
success: false,
get error() {
if (!error) {
error = new Err(issues.map((iss) => finalizeIssue(iss, ctx, config())));
issues = void 0;
ctx = void 0;
}
return error;
},
set error(e) {
error = e;
issues = void 0;
ctx = void 0;
}
};
}
const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
const ctx = _ctx ? {
..._ctx,
async: true
} : { async: true };
let result = schema._zod.run({
value,
issues: []
}, ctx);
if (result instanceof Promise) result = await result;
return result.issues.length ? failure(_Err, result.issues, ctx) : {
success: true,
data: result.value
};
};
const COMPILE_INVALID = /* @__PURE__ */ Symbol.for("zod.compile.invalid");
const COMPILE_FALLBACK = /* @__PURE__ */ Symbol.for("zod.compile.fallback");
const validate = ((schema, value, _ctx) => {
const validator = schema._zod.bag.validator;
if (validator !== void 0) {
if (validator(value) !== COMPILE_INVALID) return true;
if (validator.definite === true && _ctx === void 0) return false;
}
return validateFallback(schema, value, _ctx);
});
function validateFallback(schema, value, _ctx) {
const ctx = _ctx ? {
..._ctx,
async: false,
abortEarly: true
} : {
async: false,
abortEarly: true
};
const fallbackRun = schema._zod.bag.fallbackRun;
let result;
if (fallbackRun) {
ctx[COMPILE_FALLBACK] = true;
result = fallbackRun({
value,
issues: []
}, ctx);
} else result = schema._zod.run({
value,
issues: []
}, ctx);
if (result instanceof Promise) throw new $ZodAsyncError();
return result.issues.length === 0;
}
const validateAsync$1 = async (schema, value, _ctx) => {
const ctx = _ctx ? {
..._ctx,
async: true,
abortEarly: true
} : {
async: true,
abortEarly: true
};
let result = schema._zod.run({
value,
issues: []
}, ctx);
if (result instanceof Promise) result = await result;
return result.issues.length === 0;
};
const _encode = (_Err) => {
const parse = _parse(_Err);
const fn = (schema, value, _ctx, _params) => {
const ctx = _ctx ? {
..._ctx,
direction: "backward"
} : { direction: "backward" };
return parse(schema, value, ctx, finalizeParams(fn, _params));
};
return fn;
};
const _decode = (_Err) => {
const parse = _parse(_Err);
const fn = (schema, value, _ctx, _params) => {
return parse(schema, value, _ctx, finalizeParams(fn, _params));
};
return fn;
};
const _encodeAsync = (_Err) => {
const parseAsync = _parseAsync(_Err);
const fn = async (schema, value, _ctx, _params) => {
const ctx = _ctx ? {
..._ctx,
direction: "backward"
} : { direction: "backward" };
return await parseAsync(schema, value, ctx, finalizeParams(fn, _params));
};
return fn;
};
const _decodeAsync = (_Err) => {
const parseAsync = _parseAsync(_Err);
const fn = async (schema, value, _ctx, _params) => {
return await parseAsync(schema, value, _ctx, finalizeParams(fn, _params));
};
return fn;
};
const _safeEncode = (_Err) => (schema, value, _ctx) => {
const ctx = _ctx ? {
..._ctx,
direction: "backward"
} : { direction: "backward" };
return _safeParse(_Err)(schema, value, ctx);
};
const _safeDecode = (_Err) => (schema, value, _ctx) => {
return _safeParse(_Err)(schema, value, _ctx);
};
const _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
const ctx = _ctx ? {
..._ctx,
direction: "backward"
} : { direction: "backward" };
return _safeParseAsync(_Err)(schema, value, ctx);
};
const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
return _safeParseAsync(_Err)(schema, value, _ctx);
};
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/regexes.js
/**
* @deprecated CUID v1 is deprecated by its authors due to information leakage
* (timestamps embedded in the id). Use {@link cuid2} instead.
* See https://github.com/paralleldrive/cuid.
*/
const cuid = /^[cC][0-9a-z]{6,}$/;
const cuid2 = /^[0-9a-z]+$/;
const ulid = /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/;
const xid = /^[0-9a-vA-V]{20}$/;
const ksuid = /^[A-Za-z0-9]{27}$/;
const nanoid = /^[a-zA-Z0-9_-]{21}$/;
function nanoidOfLength(length) {
return new RegExp(`^[a-zA-Z0-9_-]{${length}}$`);
}
/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */
const duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */
const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
/** Returns a regex for validating an RFC 9562/4122 UUID.
*
* @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */
const uuid = (version) => {
if (!version) return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
};
/** Practical email validation */
const email = /^(?:[A-Za-z0-9_'+\-]+\.)*[A-Za-z0-9_'+\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
const _emoji$1 = `^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`;
function emoji() {
return new RegExp(_emoji$1, "u");
}
const ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
const cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
const cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
const base64url = /^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2,3})?$/;
const httpProtocol = /^https?$/;
const e164 = /^\+[1-9]\d{6,14}$/;
const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
/** Anchors a pattern source. The interpolation lives here rather than at the call site because
* esbuild will not drop a `@__PURE__` call whose own argument interpolates a variable, but it
* will drop `anchor(dateSource)`. Keeping it inline pinned `date` into every bundle. */
function anchor(source) {
return new RegExp(`^${source}$`);
}
const date = /*@__PURE__*/ anchor(dateSource);
function timeSource(args) {
const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
return typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : args.seconds ? `${hhmm}:[0-5]\\d(?:\\.\\d+)?` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
}
function time(args) {
return new RegExp(`^${timeSource(args)}$`);
}
function datetime(args) {
const opts = ["Z"];
if (args.offset) opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
const qualified = `${timeSource({
precision: args.precision,
seconds: true
})}(?:${opts.join("|")})`;
const timeRegex = args.local ? `${qualified}|${timeSource({ precision: args.precision })}` : qualified;
return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
}
const anyString = /^[\s\S]{0,}$/;
const number$1 = /^-?\d+(?:\.\d+)?$/;
const boolean$1 = /^(?:true|false)$/i;
const lowercase = /^[^A-Z]*$/;
const uppercase = /^[^a-z]*$/;
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/checks.js
const $ZodCheck = /*@__PURE__*/ $constructor("$ZodCheck", (inst, def) => {
var _a;
inst._zod ?? (inst._zod = {});
inst._zod.def = def;
(_a = inst._zod).onattach ?? (_a.onattach = []);
});
/** Default `when` for length-based checks: run only on non-nullish values with a `length`. */
const _whenHasLength = (payload) => {
const val = payload.value;
return !nullish(val) && val.length !== void 0;
};
const numericOriginMap = {
number: "number",
bigint: "bigint",
object: "date"
};
const $ZodCheckLessThan = /*@__PURE__*/ $constructor("$ZodCheckLessThan", (inst, def) => {
$ZodCheck.init(inst, def);
const origin = numericOriginMap[typeof def.value];
inst._zod.check = (payload) => {
if (def.inclusive ? payload.value <= def.value : payload.value < def.value) return;
payload.issues.push({
origin: numericOriginMap[typeof payload.value] ?? origin,
code: "too_big",
maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
input: payload.value,
inclusive: def.inclusive,
inst,
continue: !def.abort
});
};
});
const $ZodCheckGreaterThan = /*@__PURE__*/ $constructor("$ZodCheckGreaterThan", (inst, def) => {
$ZodCheck.init(inst, def);
const origin = numericOriginMap[typeof def.value];
inst._zod.check = (payload) => {
if (def.inclusive ? payload.value >= def.value : payload.value > def.value) return;
payload.issues.push({
origin: numericOriginMap[typeof payload.value] ?? origin,
code: "too_small",
minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
input: payload.value,
inclusive: def.inclusive,
inst,
continue: !def.abort
});
};
});
const $ZodCheckMultipleOf = /*@__PURE__*/ $constructor("$ZodCheckMultipleOf", (inst, def) => {
$ZodCheck.init(inst, def);
inst._zod.check = (payload) => {
if (typeof payload.value !== typeof def.value) throw new Error("Cannot mix number and bigint in multiple_of check.");
if (typeof payload.value === "bigint" ? def.value !== BigInt(0) && payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0) return;
payload.issues.push({
origin: typeof payload.value,
code: "not_multiple_of",
divisor: def.value,
input: payload.value,
inst,
continue: !def.abort
});
};
});
const $ZodCheckNumberFormat = /*@__PURE__*/ $constructor("$ZodCheckNumberFormat", (inst, def) => {
$ZodCheck.init(inst, def);
def.format = def.format || "float64";
const isInt = def.format?.includes("int");
const origin = isInt ? "int" : "number";
const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
inst._zod.check = (payload) => {
const input = payload.value;
if (isInt) {
if (!Number.isInteger(input)) {
payload.issues.push({
expected: origin,
format: def.format,
code: "invalid_type",
continue: false,
input,
inst
});
return;
}
if (!Number.isSafeInteger(input)) {
if (input > 0) payload.issues.push({
input,
code: "too_big",
maximum: Number.MAX_SAFE_INTEGER,
note: "Integers must be within the safe integer range.",
inst,
origin,
inclusive: true,
continue: !def.abort
});
else payload.issues.push({
input,
code: "too_small",
minimum: Number.MIN_SAFE_INTEGER,
note: "Integers must be within the safe integer range.",
inst,
origin,
inclusive: true,
continue: !def.abort
});
return;
}
}
if (input < minimum) payload.issues.push({
origin: "number",
input,
code: "too_small",
minimum,
inclusive: true,
inst,
continue: !def.abort
});
if (input > maximum) payload.issues.push({
origin: "number",
input,
code: "too_big",
maximum,
inclusive: true,
inst,
continue: !def.abort
});
};
});
const $ZodCheckMaxLength = /*@__PURE__*/ $constructor("$ZodCheckMaxLength", (inst, def) => {
var _a;
$ZodCheck.init(inst, def);
(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
inst._zod.check = (payload) => {
const input = payload.value;
const units = input.length;
if ((typeof input === "string" && units > def.maximum ? codePointLength(input) : units) <= def.maximum) return;
const origin = getLengthableOrigin(input);
payload.issues.push({
origin,
code: "too_big",
maximum: def.maximum,
inclusive: true,
input,
inst,
continue: !def.abort
});
};
});
const $ZodCheckMinLength = /*@__PURE__*/ $constructor("$ZodCheckMinLength", (inst, def) => {
var _a;
$ZodCheck.init(inst, def);
(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
inst._zod.check = (payload) => {
const input = payload.value;
const units = input.length;
if ((typeof input === "string" && units >= def.minimum && units < def.minimum * 2 ? codePointLength(input) : units) >= def.minimum) return;
const origin = getLengthableOrigin(input);
payload.issues.push({
origin,
code: "too_small",
minimum: def.minimum,
inclusive: true,
input,
inst,
continue: !def.abort
});
};
});
const $ZodCheckLengthEquals = /*@__PURE__*/ $constructor("$ZodCheckLengthEquals", (inst, def) => {
var _a;
$ZodCheck.init(inst, def);
(_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
inst._zod.check = (payload) => {
const input = payload.value;
const units = input.length;
const length = typeof input === "string" && units >= def.length && units <= def.length * 2 ? codePointLength(input) : units;
if (length === def.length) return;
const origin = getLengthableOrigin(input);
const tooBig = length > def.length;
payload.issues.push({
origin,
...tooBig ? {
code: "too_big",
maximum: def.length
} : {
code: "too_small",
minimum: def.length
},
inclusive: true,
exact: true,
input: payload.value,
inst,
continue: !def.abort
});
};
});
const $ZodCheckStringFormat = /*@__PURE__*/ $constructor("$ZodCheckStringFormat", (inst, def) => {
var _a, _b;
$ZodCheck.init(inst, def);
if (def.pattern) (_a = inst._zod).check ?? (_a.check = (payload) => {
def.pattern.lastIndex = 0;
if (def.pattern.test(payload.value)) return;
payload.issues.push({
origin: "string",
code: "invalid_format",
format: def.format,
input: payload.value,
...def.pattern ? { pattern: def.pattern.toString() } : {},
inst,
continue: !def.abort
});
});
else (_b = inst._zod).check ?? (_b.check = () => {});
});
const $ZodCheckRegex = /*@__PURE__*/ $constructor("$ZodCheckRegex", (inst, def) => {
$ZodCheckStringFormat.init(inst, def);
inst._zod.check = (payload) => {
def.pattern.lastIndex = 0;
if (def.pattern.test(payload.value)) return;
payload.issues.push({
origin: "string",
code: "invalid_format",
format: "regex",
input: payload.value,
pattern: def.pattern.toString(),
inst,
continue: !def.abort
});
};
});
const $ZodCheckLowerCase = /*@__PURE__*/ $constructor("$ZodCheckLowerCase", (inst, def) => {
def.pattern ?? (def.pattern = lowercase);
$ZodCheckStringFormat.init(inst, def);
});
const $ZodCheckUpperCase = /*@__PURE__*/ $constructor("$ZodCheckUpperCase", (inst, def) => {
def.pattern ?? (def.pattern = uppercase);
$ZodCheckStringFormat.init(inst, def);
});
const $ZodCheckIncludes = /*@__PURE__*/ $constructor("$ZodCheckIncludes", (inst, def) => {
$ZodCheck.init(inst, def);
const escapedRegex = escapeRegex(def.includes);
def.pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position},}${escapedRegex}` : escapedRegex);
inst._zod.check = (payload) => {
if (payload.value.includes(def.includes, def.position)) return;
payload.issues.push({
origin: "string",
code: "invalid_format",
format: "includes",
includes: def.includes,
input: payload.value,
inst,
continue: !def.abort
});
};
});
const $ZodCheckStartsWith = /*@__PURE__*/ $constructor("$ZodCheckStartsWith", (inst, def) => {
$ZodCheck.init(inst, def);
const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
def.pattern ?? (def.pattern = pattern);
inst._zod.check = (payload) => {
if (payload.value.startsWith(def.prefix)) return;
payload.issues.push({
origin: "string",
code: "invalid_format",
format: "starts_with",
prefix: def.prefix,
input: payload.value,
inst,
continue: !def.abort
});
};
});
const $ZodCheckEndsWith = /*@__PURE__*/ $constructor("$ZodCheckEndsWith", (inst, def) => {
$ZodCheck.init(inst, def);
const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
def.pattern ?? (def.pattern = pattern);
inst._zod.check = (payload) => {
if (payload.value.endsWith(def.suffix)) return;
payload.issues.push({
origin: "string",
code: "invalid_format",
format: "ends_with",
suffix: def.suffix,
input: payload.value,
inst,
continue: !def.abort
});
};
});
const $ZodCheckOverwrite = /*@__PURE__*/ $constructor("$ZodCheckOverwrite", (inst, def) => {
$ZodCheck.init(inst, def);
inst._zod.check = (payload) => {
payload.value = def.tx(payload.value);
};
});
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/doc.js
var Doc = class {
constructor(args = [], closed = {}) {
this.content = [];
this.indent = 0;
this.args = args;
this.closed = closed;
}
indented(fn) {
this.indent += 1;
try {
fn(this);
} finally {
this.indent -= 1;
}
}
write(arg) {
if (typeof arg === "function") {
arg(this, { execution: "sync" });
arg(this, { execution: "async" });
return;
}
const lines = arg.split("\n").filter((x) => x);
const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
for (const line of dedented) this.content.push(line);
}
compile() {
const F = Function;
const content = this?.content ?? [``];
return new F(...Object.keys(this.closed), `return function (${this.args.join(", ")}) {\n${content.join("\n")}\n};`)(...Object.values(this.closed));
}
};
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/versions.js
const version = {
major: 4,
minor: 6,
patch: 5
};
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/schemas.js
const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
var _a;
inst ?? (inst = {});
inst._zod.def = def;
inst._zod.bag = inst._zod.bag || {};
inst._zod.version = version;
const defChecks = inst._zod.def.checks;
const checks = inst._zod.traits.has("$ZodCheck") ? [inst, ...defChecks ?? []] : defChecks?.length ? [...defChecks] : [];
for (const ch of checks) for (const fn of ch._zod.onattach) fn(inst);
if (checks.length === 0) {
(_a = inst._zod).deferred ?? (_a.deferred = []);
inst._zod.deferred?.push(() => {
inst._zod.run = inst._zod.parse;
});
} else {
const runChecks = (payload, checks, ctx) => {
if (payload.memo) return payload;
let isAborted = aborted(payload);
let asyncResult;
for (const ch of checks) {
if (ch._zod.def.when) {
if (explicitlyAborted(payload)) continue;
if (!ch._zod.def.when(payload)) continue;
} else if (isAborted) continue;
const currLen = payload.issues.length;
const _ = ch._zod.check(payload);
if (_ instanceof Promise && ctx?.async === false) throw new $ZodAsyncError();
if (asyncResult || _ instanceof Promise) asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
await _;
if (payload.issues.length === currLen) return;
attachSchema(payload.issues, currLen, inst);
if (!isAborted) isAborted = aborted(payload, currLen);
});
else {
if (payload.issues.length === currLen) continue;
attachSchema(payload.issues, currLen, inst);
if (!isAborted) isAborted = aborted(payload, currLen);
}
}
if (asyncResult) return asyncResult.then(() => {
return payload;
});
return payload;
};
const handleCanaryResult = (canary, payload, ctx) => {
if (aborted(canary)) {
canary.aborted = true;
return canary;
}
const checkResult = runChecks(payload, checks, ctx);
if (checkResult instanceof Promise) {
if (ctx.async === false) throw new $ZodAsyncError();
return checkResult.then((checkResult) => inst._zod.parse(checkResult, ctx));
}
return inst._zod.parse(checkResult, ctx);
};
inst._zod.run = (payload, ctx) => {
if (ctx.skipChecks) return inst._zod.parse(payload, ctx);
if (ctx.direction === "backward") {
const canary = inst._zod.parse({
value: payload.value,
issues: []
}, {
...ctx,
skipChecks: true
});
if (canary instanceof Promise) return canary.then((canary) => {
return handleCanaryResult(canary, payload, ctx);
});
return handleCanaryResult(canary, payload, ctx);
}
const result = inst._zod.parse(payload, ctx);
if (result instanceof Promise) {
if (ctx.async === false) throw new $ZodAsyncError();
return result.then((result) => runChecks(result, checks, ctx));
}
return runChecks(result, checks, ctx);
};
}
}, {
get "~standard"() {
return hide(this, "~standard", standardProps(this));
},
set "~standard"(value) {
own(this, "~standard", value);
}
});
/** The Standard Schema surface for `inst`. Shared so wrappers can extend it without forcing it. */
const toStandardResult = (r, ctx) => r.issues.length ? { issues: r.issues.map((iss) => finalizeIssue(iss, ctx, config())) } : { value: r.value };
async function validateAsync(inst, value) {
const ctx = { async: true };
return toStandardResult(await inst._zod.run({
value,
issues: []
}, ctx), ctx);
}
function standardProps(inst) {
return {
validate: (value) => {
const ctx = { async: false };
try {
const r = inst._zod.run({
value,
issues: []
}, ctx);
if (!(r instanceof Promise)) return toStandardResult(r, ctx);
} catch (_) {}
return validateAsync(inst, value);
},
vendor: "zod",
version: 1
};
}
const $ZodString = /*@__PURE__*/ $constructor("$ZodString", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = def.pattern ?? anyString;
inst._zod.parse = (payload, _) => {
if (def.coerce) try {
payload.value = String(payload.value);
} catch (_) {}
if (typeof payload.value === "string") return payload;
payload.issues.push({
expected: "string",
code: "invalid_type",
input: payload.value,
inst
});
return payload;
};
});
const $ZodStringFormat = /*@__PURE__*/ $constructor("$ZodStringFormat", (inst, def) => {
$ZodCheckStringFormat.init(inst, def);
$ZodString.init(inst, def);
});
const $ZodGUID = /*@__PURE__*/ $constructor("$ZodGUID", (inst, def) => {
def.pattern ?? (def.pattern = guid);
$ZodStringFormat.init(inst, def);
});
const $ZodUUID = /*@__PURE__*/ $constructor("$ZodUUID", (inst, def) => {
if (def.version) {
const v = {
v1: 1,
v2: 2,
v3: 3,
v4: 4,
v5: 5,
v6: 6,
v7: 7,
v8: 8
}[def.version];
if (v === void 0) throw new Error(`Invalid UUID version: "${def.version}"`);
def.pattern ?? (def.pattern = uuid(v));
} else def.pattern ?? (def.pattern = uuid());
$ZodStringFormat.init(inst, def);
});
const $ZodEmail = /*@__PURE__*/ $constructor("$ZodEmail", (inst, def) => {
def.pattern ?? (def.pattern = email);
$ZodStringFormat.init(inst, def);
});
function canParseURL(input) {
try {
if (typeof URL !== "undefined" && typeof URL.canParse === "function") return URL.canParse(input);
new URL(input);
return true;
} catch {
return false;
}
}
function validateURL(trimmed, def) {
if (!("normalize" in def) && !("hostname" in def) && !("protocol" in def)) return canParseURL(trimmed) || 2;
return parseURLObject(trimmed, def);
}
/** Parses a URL while preserving the non-normalizing HTTP guard. */
function parseURLObject(trimmed, def) {
if (!def.normalize && def.protocol?.source === httpProtocol.source && !/^https?:\/\//i.test(trimmed)) return 1;
try {
if (typeof URL !== "undefined") {
const URLStatic = URL;
if (typeof URLStatic.parse === "function") return URLStatic.parse(trimmed) ?? 2;
}
return new URL(trimmed);
} catch {
return 2;
}
}
const asciiTabOrNewline = /[\t\n\r]/g;
/** The URL parser deletes every ASCII tab, LF and CR from its input before it parses, so `new URL("https://exa\nmple.com")` reports on `example.com`. Applying the same deletion to the returned value closes the half of that divergence which can move the host; the parser's other rewrite, stripping C0 controls at the edges, cannot. */
function stripTabAndNewline(value) {
return value.replace(asciiTabOrNewline, "");
}
function urlHostnameOk(url, hostname) {
hostname.lastIndex = 0;
return hostname.test(url.hostname);
}
function urlProtocolOk(url, protocol) {
protocol.lastIndex = 0;
return protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol);
}
const $ZodURL = /*@__PURE__*/ $constructor("$ZodURL", (inst, def) => {
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
try {
const trimmed = payload.value.trim();
const url = validateURL(trimmed, def);
if (url === 1) {
payload.issues.push({
code: "invalid_format",
format: "url",
note: "Invalid URL format",
input: payload.value,
inst,
continue: !def.abort
});
return;
}
if (url === 2) {
payload.issues.push({
code: "invalid_format",
format: "url",
input: payload.value,
inst,
continue: !def.abort
});
return;
}
if (url === true) {
payload.value = stripTabAndNewline(trimmed);
return;
}
if (def.hostname && !urlHostnameOk(url, def.hostname)) payload.issues.push({
code: "invalid_format",
format: "url",
note: "Invalid hostname",
pattern: def.hostname.source,
input: payload.value,
inst,
continue: !def.abort
});
if (def.protocol && !urlProtocolOk(url, def.protocol)) payload.issues.push({
code: "invalid_format",
format: "url",
note: "Invalid protocol",
pattern: def.protocol.source,
input: payload.value,
inst,
continue: !def.abort
});
payload.value = def.normalize ? url.href : stripTabAndNewline(trimmed);
return;
} catch (_) {
payload.issues.push({
code: "invalid_format",
format: "url",
input: payload.value,
inst,
continue: !def.abort
});
}
};
});
const $ZodEmoji = /*@__PURE__*/ $constructor("$ZodEmoji", (inst, def) => {
def.pattern ?? (def.pattern = emoji());
$ZodStringFormat.init(inst, def);
});
const $ZodNanoID = /*@__PURE__*/ $constructor("$ZodNanoID", (inst, def) => {
if (def.length !== void 0 && (!Number.isInteger(def.length) || def.length < 1)) throw new Error(`Invalid nanoid length: ${def.length}`);
def.pattern ?? (def.pattern = def.length === void 0 ? nanoid : nanoidOfLength(def.length));
$ZodStringFormat.init(inst, def);
});
/**
* @deprecated CUID v1 is deprecated by its authors due to information leakage
* (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
* See https://github.com/paralleldrive/cuid.
*/
const $ZodCUID = /*@__PURE__*/ $constructor("$ZodCUID", (inst, def) => {
def.pattern ?? (def.pattern = cuid);
$ZodStringFormat.init(inst, def);
});
const $ZodCUID2 = /*@__PURE__*/ $constructor("$ZodCUID2", (inst, def) => {
def.pattern ?? (def.pattern = cuid2);
$ZodStringFormat.init(inst, def);
});
const $ZodULID = /*@__PURE__*/ $constructor("$ZodULID", (inst, def) => {
def.pattern ?? (def.pattern = ulid);
$ZodStringFormat.init(inst, def);
});
const $ZodXID = /*@__PURE__*/ $constructor("$ZodXID", (inst, def) => {
def.pattern ?? (def.pattern = xid);
$ZodStringFormat.init(inst, def);
});
const $ZodKSUID = /*@__PURE__*/ $constructor("$ZodKSUID", (inst, def) => {
def.pattern ?? (def.pattern = ksuid);
$ZodStringFormat.init(inst, def);
});
const $ZodISODateTime = /*@__PURE__*/ $constructor("$ZodISODateTime", (inst, def) => {
def.pattern ?? (def.pattern = datetime(def));
$ZodStringFormat.init(inst, def);
});
const $ZodISODate = /*@__PURE__*/ $constructor("$ZodISODate", (inst, def) => {
def.pattern ?? (def.pattern = date);
$ZodStringFormat.init(inst, def);
});
const $ZodISOTime = /*@__PURE__*/ $constructor("$ZodISOTime", (inst, def) => {
def.pattern ?? (def.pattern = time(def));
$ZodStringFormat.init(inst, def);
});
const $ZodISODuration = /*@__PURE__*/ $constructor("$ZodISODuration", (inst, def) => {
def.pattern ?? (def.pattern = duration);
$ZodStringFormat.init(inst, def);
});
const $ZodIPv4 = /*@__PURE__*/ $constructor("$ZodIPv4", (inst, def) => {
def.pattern ?? (def.pattern = ipv4);
$ZodStringFormat.init(inst, def);
});
/** An IPv6 address is written with hex digits, colons and dots, and nothing else. The guard is what makes the check below an IPv6 check: `new URL("http://[...]")` parses an authority, not an address, so `@` and `\` re-delimit it and `"::@1\\"` validates against the host `0.0.0.1`. The URL parser also deletes ASCII tab, LF and CR rather than failing, which is how `"::1\n"` validated as `::1`. */
const ipv6Alphabet = /^[0-9a-fA-F:.]+$/;
function isValidIPv6(value) {
if (!ipv6Alphabet.test(value)) return false;
return canParseURL(`http://[${value}]`);
}
const $ZodIPv6 = /*@__PURE__*/ $constructor("$ZodIPv6", (inst, def) => {
def.pattern ?? (def.pattern = ipv6);
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
if (!isValidIPv6(payload.value)) payload.issues.push({
code: "invalid_format",
format: "ipv6",
input: payload.value,
inst,
continue: !def.abort
});
};
});
const $ZodCIDRv4 = /*@__PURE__*/ $constructor("$ZodCIDRv4", (inst, def) => {
def.pattern ?? (def.pattern = cidrv4);
$ZodStringFormat.init(inst, def);
});
function isValidCIDRv6(value) {
const parts = value.split("/");
if (parts.length !== 2) return false;
const [address, prefix] = parts;
if (!prefix) return false;
const prefixNum = Number(prefix);
if (`${prefixNum}` !== prefix) return false;
if (prefixNum < 0 || prefixNum > 128) return false;
return isValidIPv6(address);
}
const $ZodCIDRv6 = /*@__PURE__*/ $constructor("$ZodCIDRv6", (inst, def) => {
def.pattern ?? (def.pattern = cidrv6);
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
if (!isValidCIDRv6(payload.value)) payload.issues.push({
code: "invalid_format",
format: "cidrv6",
input: payload.value,
inst,
continue: !def.abort
});
};
});
function isValidBase64(data) {
if (data === "") return true;
if (/\s/.test(data)) return false;
if (data.length % 4 !== 0) return false;
try {
atob(data);
return true;
} catch {
return false;
}
}
const base64Charset = /^[0-9a-zA-Z+/]*={0,2}$/;
const $ZodBase64 = /*@__PURE__*/ $constructor("$ZodBase64", (inst, def) => {
def.pattern ?? (def.pattern = base64Charset);
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
if (isValidBase64(payload.value)) return;
payload.issues.push({
code: "invalid_format",
format: "base64",
input: payload.value,
inst,
continue: !def.abort
});
};
});
const base64urlCharset = /^[A-Za-z0-9_-]*$/;
function isValidBase64URL(data) {
if (!base64urlCharset.test(data)) return false;
const base64 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
return isValidBase64(base64.padEnd(Math.ceil(base64.length / 4) * 4, "="));
}
const $ZodBase64URL = /*@__PURE__*/ $constructor("$ZodBase64URL", (inst, def) => {
def.pattern ?? (def.pattern = base64urlCharset);
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
if (isValidBase64URL(payload.value)) return;
payload.issues.push({
code: "invalid_format",
format: "base64url",
input: payload.value,
inst,
continue: !def.abort
});
};
});
const $ZodE164 = /*@__PURE__*/ $constructor("$ZodE164", (inst, def) => {
def.pattern ?? (def.pattern = e164);
$ZodStringFormat.init(inst, def);
});
function isValidJWT(token, algorithm = null) {
try {
const tokensParts = token.split(".");
if (tokensParts.length !== 3) return false;
const [header] = tokensParts;
if (!header) return false;
const parsedHeader = JSON.parse(atob(header));
if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") return false;
if (!parsedHeader.alg) return false;
if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) return false;
return true;
} catch {
return false;
}
}
const $ZodJWT = /*@__PURE__*/ $constructor("$ZodJWT", (inst, def) => {
$ZodStringFormat.init(inst, def);
inst._zod.check = (payload) => {
if (isValidJWT(payload.value, def.alg)) return;
payload.issues.push({
code: "invalid_format",
format: "jwt",
input: payload.value,
inst,
continue: !def.abort
});
};
});
const $ZodNumber = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = number$1;
inst._zod.parse = (payload, _ctx) => {
if (def.coerce) try {
payload.value = Number(payload.value);
} catch (_) {}
const input = payload.value;
if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) return payload;
const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? String(input) : void 0 : void 0;
payload.issues.push({
expected: "number",
code: "invalid_type",
input,
inst,
...received ? { received } : {}
});
return payload;
};
});
const $ZodNumberFormat = /*@__PURE__*/ $constructor("$ZodNumberFormat", (inst, def) => {
$ZodCheckNumberFormat.init(inst, def);
$ZodNumber.init(inst, def);
});
const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.pattern = boolean$1;
inst._zod.parse = (payload, _ctx) => {
if (def.coerce) try {
payload.value = Boolean(payload.value);
} catch (_) {}
const input = payload.value;
if (typeof input === "boolean") return payload;
payload.issues.push({
expected: "boolean",
code: "invalid_type",
input,
inst
});
return payload;
};
});
const $ZodUnknown = /*@__PURE__*/ $constructor("$ZodUnknown", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload) => payload;
});
const $ZodNever = /*@__PURE__*/ $constructor("$ZodNever", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, _ctx) => {
payload.issues.push({
expected: "never",
code: "invalid_type",
input: payload.value,
inst
});
return payload;
};
});
function handleArrayResult(result, final, index) {
if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
final.value[index] = result.value;
}
const $ZodArray = /*@__PURE__*/ $constructor("$ZodArray", (inst, def) => {
$ZodType.init(inst, def);
const memo = globalConfig.memoizer;
memo?.attach(inst);
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
if (!Array.isArray(input)) {
payload.issues.push({
expected: "array",
code: "invalid_type",
input,
inst
});
return payload;
}
payload.value = memo ? memo.alloc(inst, payload, Array(input.length), ctx) : Array(input.length);
const proms = [];
const abortEarly = ctx?.abortEarly;
for (let i = 0; i < input.length; i++) {
const item = input[i];
const result = def.element._zod.run({
value: item,
issues: []
}, ctx);
if (result instanceof Promise) proms.push(result.then((result) => handleArrayResult(result, payload, i)));
else {
handleArrayResult(result, payload, i);
if (abortEarly && result.issues.length !== 0 && aborted(result)) break;
}
}
if (proms.length) return Promise.all(proms).then(() => payload);
return payload;
};
});
function handlePropertyResult(result, final, key, input, optin, optout) {
const isPresent = key in input;
const isOptionalOut = optout === "optional";
if (!isPresent && isOptionalOut && optin === "optional") return;
if (result.issues.length) {
if (optin !== void 0 && isOptionalOut && !isPresent) return;
final.issues.push(...prefixIssues(key, result.issues));
}
if (!isPresent && optin === void 0) {
if (!result.issues.length) final.issues.push({
code: "invalid_type",
expected: "nonoptional",
input: void 0,
path: [key]
});
return;
}
if (result.value === void 0) {
if (isPresent || optin === "defaulted" && !isOptionalOut) final.value[key] = void 0;
} else final.value[key] = result.value;
}
const NO_SYMBOL_KEYS = [];
function normalizeDef(def) {
const keys = Object.keys(def.shape);
const ownSymbols = Object.getOwnPropertySymbols(def.shape);
const symbolKeys = ownSymbols.length ? ownSymbols : NO_SYMBOL_KEYS;
const allKeys = symbolKeys.length ? [...keys, ...symbolKeys] : keys;
for (const k of allKeys) if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) throw new Error(`Invalid element at key "${String(k)}": expected a Zod schema`);
const okeys = optionalKeys(def.shape);
return {
...def,
allKeys,
symbolKeys,
keySet: new Set(keys),
numKeys: keys.length,
optionalKeys: new Set(okeys)
};
}
function handleCatchall(proms, input, payload, ctx, def, inst, abortEarly) {
const unrecognized = [];
const keySet = def.keySet;
const _catchall = def.catchall._zod;
const t = _catchall.def.type;
const optin = _catchall.optin;
const optout = _catchall.optout;
let seen = 0;
for (const key in input) {
if (abortEarly && payload.issues.length !== seen) {
if (aborted(payload, seen)) break;
seen = payload.issues.length;
}
if (keySet.has(key)) continue;
if (key === "__proto__") {
if (t === "never") unrecognized.push(key);
continue;
}
if (t === "never") {
unrecognized.push(key);
continue;
}
const r = _catchall.run({
value: input[key],
issues: []
}, ctx);
if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, optin, optout)));
else handlePropertyResult(r, payload, key, input, optin, optout);
}
if (unrecognized.length) payload.issues.push({
code: "unrecognized_keys",
keys: unrecognized,
input,
inst,
continue: true
});
if (!proms.length) return payload;
return Promise.all(proms).then(() => {
return payload;
});
}
const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
$ZodType.init(inst, def);
const desc = Object.getOwnPropertyDescriptor(def, "shape");
const sh = desc?.get ? desc.get.raw : def.shape ?? {};
if (sh) {
const get = () => {
const newSh = { ...sh };
Object.defineProperty(def, "shape", { value: newSh });
get.raw = newSh;
return newSh;
};
get.raw = sh;
Object.defineProperty(def, "shape", { get });
}
const _normalized = cached(() => normalizeDef(def));
defineLazyInternal(inst, "propValues", (zod) => {
const shape = zod.def.shape;
const propValues = {};
for (const key in shape) {
const field = shape[key]._zod;
if (field.values) {
if (!Object.prototype.hasOwnProperty.call(propValues, key)) assignProp(propValues, key, /* @__PURE__ */ new Set());
for (const v of field.values) propValues[key].add(v);
if (field.optin !== void 0) propValues[key].add(void 0);
}
}
return propValues;
});
const isObject$2 = isObject;
const catchall = def.catchall;
let value;
const memo = globalConfig.memoizer;
memo?.attach(inst);
inst._zod.parse = (payload, ctx) => {
value ?? (value = _normalized.value);
const input = payload.value;
if (!isObject$2(input)) {
payload.issues.push({
expected: "object",
code: "invalid_type",
input,
inst
});
return payload;
}
payload.value = memo ? memo.alloc(inst, payload, {}, ctx) : {};
const proms = [];
const shape = value.shape;
const abortEarly = ctx?.abortEarly;
let seen = payload.issues.length;
for (const key of value.allKeys) {
if (abortEarly && payload.issues.length !== seen) {
if (aborted(payload, seen)) break;
seen = payload.issues.length;
}
if (key === "__proto__") continue;
const el = shape[key];
const optin = el._zod.optin;
const optout = el._zod.optout;
const r = el._zod.run({
value: input[key],
issues: []
}, ctx);
if (r instanceof Promise) proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, optin, optout)));
else handlePropertyResult(r, payload, key, input, optin, optout);
}
if (!catchall) return proms.length ? Promise.all(proms).then(() => payload) : payload;
return handleCatchall(proms, input, payload, ctx, _normalized.value, inst, abortEarly === true);
};
});
const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) => {
$ZodObject.init(inst, def);
const superParse = inst._zod.parse;
const _normalized = cached(() => normalizeDef(def));
const memo = globalConfig.memoizer;
const generateFastpass = (shape) => {
const normalized = _normalized.value;
const syms = normalized.symbolKeys;
const doc = new Doc(["payload", "ctx"], {
shape,
inst,
memo,
syms
});
const parseStr = (k) => `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
const prefixStr = (id, k) => `
let ${id}_ab = false;
for (let i = 0; i < ${id}.issues.length; i++) {
const iss = ${id}.issues[i];
iss.path = iss.path ? [${k}, ...iss.path] : [${k}];
payload.issues.push(iss);
if (iss.continue !== true) ${id}_ab = true;
}
if (${id}_ab && ctx && ctx.abortEarly) {
payload.value = newResult;
return payload;
}`;
doc.write(`const input = payload.value;`);
const ids = Object.create(null);
let counter = 0;
for (const key of normalized.allKeys) ids[key] = `key_${counter++}`;
doc.write(memo ? `const newResult = memo.alloc(inst, payload, {}, ctx);` : `const newResult = {};`);
for (const key of normalized.allKeys) {
if (key === "__proto__") continue;
const id = ids[key];
const k = typeof key === "symbol" ? `syms[${syms.indexOf(key)}]` : esc(key);
const isPresent = `${k} in input`;
const schema = shape[key];
const optin = schema?._zod?.optin;
const isOptionalIn = optin !== void 0;
const isOptionalOut = schema?._zod?.optout === "optional";
doc.write(`const ${id} = ${parseStr(k)};`);
if (isOptionalIn && isOptionalOut) {
const assign = optin === "optional" ? `${id}_present` : `${id}.value !== undefined || ${id}_present`;
doc.write(`
const ${id}_present = ${isPresent};
if (!${id}.issues.length || ${id}_present) {
if (${id}.issues.length) {${prefixStr(id, k)}
}
if (${assign}) {
newResult[${k}] = ${id}.value;
}
}
`);
} else if (!isOptionalIn) doc.write(`
const ${id}_present = ${isPresent};
if (${id}.issues.length) {${prefixStr(id, k)}
}
if (!${id}_present && !${id}.issues.length) {
payload.issues.push({
code: "invalid_type",
expected: "nonoptional",
input: undefined,
path: [${k}]
});
if (ctx && ctx.abortEarly) {
payload.value = newResult;
return payload;
}
}
if (${id}_present) {
newResult[${k}] = ${id}.value;
}
`);
else {
doc.write(`
if (${id}.issues.length) {${prefixStr(id, k)}
}
`);
if (optin === "defaulted") doc.write(`newResult[${k}] = ${id}.value;`);
else doc.write(`
if (${id}.value !== undefined || ${isPresent}) {
newResult[${k}] = ${id}.value;
}
`);
}
}
doc.write(`payload.value = newResult;`);
doc.write(`return payload;`);
return doc.compile();
};
let fastpass;
const isObject$1 = isObject;
const jit = !globalConfig.jitless;
const fastEnabled = jit && allowsEval.value;
const catchall = def.catchall;
let value;
inst._zod.parse = (payload, ctx) => {
value ?? (value = _normalized.value);
const input = payload.value;
if (!isObject$1(input)) {
payload.issues.push({
expected: "object",
code: "invalid_type",
input,
inst
});
return payload;
}
if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
if (!fastpass) fastpass = generateFastpass(def.shape);
payload = fastpass(payload, ctx);
if (!catchall) return payload;
return handleCatchall([], input, payload, ctx, value, inst, ctx?.abortEarly === true);
}
return superParse(payload, ctx);
};
});
function handleUnionResults(results, final, inst, ctx) {
for (const result of results) if (result.issues.length === 0) {
final.value = result.value;
return final;
}
const nonaborted = results.filter((r) => !aborted(r));
if (nonaborted.length === 1) {
final.value = nonaborted[0].value;
return nonaborted[0];
}
final.issues.push({
code: "invalid_union",
input: final.value,
inst,
errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
});
return final;
}
const $ZodUnion = /*@__PURE__*/ $constructor("$ZodUnion", (inst, def) => {
$ZodType.init(inst, def);
defineLazyInternal(inst, "optin", (zod) => zod.def.options.some((o) => o._zod.optin === "defaulted") ? "defaulted" : zod.def.options.some((o) => o._zod.optin !== void 0) ? "optional" : void 0);
defineLazyInternal(inst, "optout", (zod) => zod.def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
defineLazyInternal(inst, "values", (zod) => {
if (zod.def.options.every((o) => o._zod.values)) return new Set(zod.def.options.flatMap((option) => Array.from(option._zod.values)));
});
defineLazyInternal(inst, "pattern", (zod) => {
if (zod.def.options.every((o) => o._zod.pattern)) {
const patterns = zod.def.options.map((o) => o._zod.pattern);
return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
}
});
const first = def.options.length === 1 ? def.options[0]._zod.run : null;
inst._zod.parse = (payload, ctx) => {
if (first) return first(payload, ctx);
let async = false;
const results = [];
for (const option of def.options) {
const result = option._zod.run({
value: payload.value,
issues: []
}, ctx);
if (result instanceof Promise) {
results.push(result);
async = true;
} else {
if (result.issues.length === 0) return result;
results.push(result);
}
}
if (!async) return handleUnionResults(results, payload, inst, ctx);
return Promise.all(results).then((results) => {
return handleUnionResults(results, payload, inst, ctx);
});
};
});
const $ZodIntersection = /*@__PURE__*/ $constructor("$ZodIntersection", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.parse = (payload, ctx) => {
const input = payload.value;
const left = def.left._zod.run({
value: input,
issues: []
}, ctx);
const right = def.right._zod.run({
value: input,
issues: []
}, ctx);
if (left instanceof Promise || right instanceof Promise) return Promise.all([left, right]).then(([left, right]) => {
return handleIntersectionResults(payload, left, right);
});
return handleIntersectionResults(payload, left, right);
};
});
function mergeValues(a, b) {
if (a === b) return {
valid: true,
data: a
};
if (a instanceof Date && b instanceof Date && +a === +b) return {
valid: true,
data: a
};
if (isPlainObject(a) && isPlainObject(b)) {
const bKeys = Object.keys(b);
const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
const newObj = {
...a,
...b
};
if (Object.prototype.hasOwnProperty.call(newObj, "__proto__")) delete newObj.__proto__;
for (const key of sharedKeys) {
if (key === "__proto__") continue;
const sharedValue = mergeValues(a[key], b[key]);
if (!sharedValue.valid) return {
valid: false,
mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
};
newObj[key] = sharedValue.data;
}
return {
valid: true,
data: newObj
};
}
if (Array.isArray(a) && Array.isArray(b)) {
if (a.length !== b.length) return {
valid: false,
mergeErrorPath: []
};
const newArray = [];
for (let index = 0; index < a.length; index++) {
const itemA = a[index];
const itemB = b[index];
const sharedValue = mergeValues(itemA, itemB);
if (!sharedValue.valid) return {
valid: false,
mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
};
newArray.push(sharedValue.data);
}
return {
valid: true,
data: newArray
};
}
return {
valid: false,
mergeErrorPath: []
};
}
function handleIntersectionResults(result, left, right) {
const unrecKeys = /* @__PURE__ */ new Map();
let unrecIssue;
const keyIssues = /* @__PURE__ */ new Map();
const collect = (iss, side) => {
let keys;
if (iss.code === "unrecognized_keys" && !iss.path?.length) {
unrecIssue ?? (unrecIssue = iss);
keys = iss.keys;
} else if (iss.code === "invalid_key" && iss.origin === "record" && iss.path?.length === 1) {
const k = String(iss.path[0]);
if (!keyIssues.has(k)) keyIssues.set(k, iss);
keys = [k];
} else return false;
for (const k of keys) {
if (!unrecKeys.has(k)) unrecKeys.set(k, {});
unrecKeys.get(k)[side] = true;
}
return true;
};
for (const iss of left.issues) if (!collect(iss, "l")) result.issues.push(iss);
for (const iss of right.issues) if (!collect(iss, "r")) result.issues.push(iss);
const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
if (bothKeys.length) {
const aggregated = unrecIssue ? bothKeys.filter((k) => unrecIssue.keys.includes(k)) : [];
if (aggregated.length) result.issues.push({
...unrecIssue,
keys: aggregated
});
for (const k of bothKeys) if (!aggregated.includes(k) && keyIssues.has(k)) result.issues.push(keyIssues.get(k));
}
const merged = mergeValues(left.value, right.value);
if (!merged.valid) {
if (aborted(result)) return result;
throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
}
result.value = merged.data;
return result;
}
const $ZodEnum = /*@__PURE__*/ $constructor("$ZodEnum", (inst, def) => {
$ZodType.init(inst, def);
const values = getEnumValues(def.entries);
const valuesSet = new Set(values);
inst._zod.values = valuesSet;
defineLazyInternal(inst, "pattern", (zod) => {
const patternValues = getEnumValues(zod.def.entries).filter((k) => propertyKeyTypes.has(typeof k));
return new RegExp(patternValues.length ? `^(${patternValues.map((o) => escapeRegex(o.toString())).join("|")})$` : "^[^\\s\\S]$");
});
inst._zod.parse = (payload, _ctx) => {
const input = payload.value;
if (valuesSet.has(input)) return payload;
payload.issues.push({
code: "invalid_value",
values,
input,
inst
});
return payload;
};
});
const $ZodLiteral = /*@__PURE__*/ $constructor("$ZodLiteral", (inst, def) => {
$ZodType.init(inst, def);
const values = new Set(def.values);
inst._zod.values = values;
defineLazyInternal(inst, "pattern", (zod) => {
const vals = zod.def.values;
return new RegExp(vals.length ? `^(${vals.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$` : "^[^\\s\\S]$");
});
inst._zod.parse = (payload, _ctx) => {
const input = payload.value;
if (values.has(input)) return payload;
payload.issues.push({
code: "invalid_value",
values: def.values,
input,
inst
});
return payload;
};
});
const $ZodTransform = /*@__PURE__*/ $constructor("$ZodTransform", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.optin = "optional";
globalConfig.memoizer?.guard(inst);
inst._zod.parse = (payload, ctx) => {
if (ctx.direction === "backward") throw new $ZodEncodeError(inst.constructor.name);
const _out = def.transform(payload.value, payload);
if (ctx.async) return (_out instanceof Promise ? _out : Promise.resolve(_out)).then((output) => {
payload.value = output;
return payload;
});
if (_out instanceof Promise) throw new $ZodAsyncError();
payload.value = _out;
return payload;
};
});
function handleOptionalResult(payload, result) {
payload.value = result.issues.length ? void 0 : result.value;
return payload;
}
const $ZodOptional = /*@__PURE__*/ $constructor("$ZodOptional", (inst, def) => {
$ZodType.init(inst, def);
defineLazyInternal(inst, "optin", (zod) => zod.def.innerType._zod.optin === "defaulted" ? "defaulted" : "optional");
inst._zod.optout = "optional";
defineLazyInternal(inst, "values", (zod) => {
const values = zod.def.innerType._zod.values;
return values ? /* @__PURE__ */ new Set([...values, void 0]) : void 0;
});
defineLazyInternal(inst, "pattern", (zod) => {
const pattern = zod.def.innerType._zod.pattern;
return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
});
inst._zod.parse = (payload, ctx) => {
if (payload.value === void 0) {
if (def.innerType._zod.optin !== "defaulted") return payload;
const result = def.innerType._zod.run({
value: payload.value,
issues: []
}, ctx);
if (result instanceof Promise) return result.then((result) => handleOptionalResult(payload, result));
return handleOptionalResult(payload, result);
}
return def.innerType._zod.run(payload, ctx);
};
});
const $ZodExactOptional = /*@__PURE__*/ $constructor("$ZodExactOptional", (inst, def) => {
$ZodOptional.init(inst, def);
defineLazyInternal(inst, "values", (zod) => zod.def.innerType._zod.values);
defineLazyInternal(inst, "pattern", (zod) => zod.def.innerType._zod.pattern);
inst._zod.parse = (payload, ctx) => {
return def.innerType._zod.run(payload, ctx);
};
});
const $ZodNullable = /*@__PURE__*/ $constructor("$ZodNullable", (inst, def) => {
$ZodType.init(inst, def);
defineLazyInternal(inst, "optin", (zod) => zod.def.innerType._zod.optin);
defineLazyInternal(inst, "optout", (zod) => zod.def.innerType._zod.optout);
defineLazyInternal(inst, "pattern", (zod) => {
const pattern = zod.def.innerType._zod.pattern;
return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
});
defineLazyInternal(inst, "values", (zod) => {
return zod.def.innerType._zod.values ? /* @__PURE__ */ new Set([...zod.def.innerType._zod.values, null]) : void 0;
});
inst._zod.parse = (payload, ctx) => {
if (payload.value === null) return payload;
return def.innerType._zod.run(payload, ctx);
};
});
const $ZodDefault = /*@__PURE__*/ $constructor("$ZodDefault", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.optin = "defaulted";
defineLazyInternal(inst, "values", (zod) => zod.def.innerType._zod.values);
inst._zod.parse = (payload, ctx) => {
if (ctx.direction === "backward") return def.innerType._zod.run(payload, ctx);
if (payload.value === void 0) {
payload.value = def.defaultValue;
/**
* $ZodDefault returns the default value immediately in forward direction.
* It doesn't pass the default value into the validator ("prefault"). There's no reason to pass the default value through validation. The validity of the default is enforced by TypeScript statically. Otherwise, it's the responsibility of the user to ensure the default is valid. In the case of pipes with divergent in/out types, you can specify the default on the `in` schema of your ZodPipe to set a "prefault" for the pipe. */
return payload;
}
const result = def.innerType._zod.run(payload, ctx);
if (result instanceof Promise) return result.then((result) => handleDefaultResult(result, def));
return handleDefaultResult(result, def);
};
});
function handleDefaultResult(payload, def) {
if (payload.value === void 0) payload.value = def.defaultValue;
return payload;
}
const $ZodPrefault = /*@__PURE__*/ $constructor("$ZodPrefault", (inst, def) => {
$ZodType.init(inst, def);
inst._zod.optin = "defaulted";
defineLazyInternal(inst, "values", (zod) => zod.def.innerType._zod.values);
inst._zod.parse = (payload, ctx) => {
if (ctx.direction === "backward") return def.innerType._zod.run(payload, ctx);
if (payload.value === void 0) payload.value = def.defaultValue;
return def.innerType._zod.run(payload, ctx);
};
});
const $ZodNonOptional = /*@__PURE__*/ $constructor("$ZodNonOptional", (inst, def) => {
$ZodType.init(inst, def);
defineLazyInternal(inst, "values", (zod) => {
const v = zod.def.innerType._zod.values;
return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
});
inst._zod.parse = (payload, ctx) => {
const result = def.innerType._zod.run(payload, ctx);
if (result instanceof Promise) return result.then((result) => handleNonOptionalResult(result, inst));
return handleNonOptionalResult(result, inst);
};
});
function handleNonOptionalResult(payload, inst) {
if (!payload.issues.length && payload.value === void 0) payload.issues.push({
code: "invalid_type",
expected: "nonoptional",
input: payload.value,
inst
});
return payload;
}
function handleCatchResult(payload, result, def, ctx) {
if (!result.issues.length) {
payload.value = result.value;
if (result.memo) payload.memo = true;
return payload;
}
payload.value = def.catchValue({
...result,
value: payload.value,
error: { issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config())) },
input: payload.value
});
return payload;
}
const $ZodCatch = /*@__PURE__*/ $constructor("$ZodCatch", (inst, def) => {
$ZodType.init(inst, def);
defineLazyInternal(inst, "optin", (zod) => zod.def.innerType._zod.optin === "defaulted" ? "defaulted" : "optional");
defineLazyInternal(inst, "optout", (zod) => zod.def.innerType._zod.optout);
defineLazyInternal(inst, "values", (zod) => zod.def.innerType._zod.values);
inst._zod.parse = (payload, ctx) => {
if (ctx.direction === "backward") return def.innerType._zod.run(payload, ctx);
const result = def.innerType._zod.run({
value: payload.value,
issues: []
}, ctx);
if (result instanceof Promise) return result.then((result) => handleCatchResult(payload, result, def, ctx));
return handleCatchResult(payload, result, def, ctx);
};
});
const $ZodPipe = /*@__PURE__*/ $constructor("$ZodPipe", (inst, def) => {
$ZodType.init(inst, def);
defineLazyInternal(inst, "values", (zod) => zod.def.in._zod.values);
defineLazyInternal(inst, "optin", (zod) => zod.def.in._zod.optin);
defineLazyInternal(inst, "optout", (zod) => zod.def.out._zod.optout);
defineLazyInternal(inst, "propValues", (zod) => zod.def.in._zod.propValues);
inst._zod.parse = (payload, ctx) => {
if (ctx.direction === "backward") {
const right = def.out._zod.run(payload, ctx);
if (right instanceof Promise) return right.then((right) => handlePipeResult(right, def.in, ctx));
return handlePipeResult(right, def.in, ctx);
}
const left = def.in._zod.run(payload, ctx);
if (left instanceof Promise) return left.then((left) => handlePipeResult(left, def.out, ctx));
return handlePipeResult(left, def.out, ctx);
};
});
function handlePipeResult(left, next, ctx) {
if (left.issues.some((iss) => iss.code !== "unrecognized_keys")) {
left.aborted = true;
return left;
}
return next._zod.run({
value: left.value,
issues: left.issues
}, ctx);
}
const $ZodReadonly = /*@__PURE__*/ $constructor("$ZodReadonly", (inst, def) => {
$ZodType.init(inst, def);
defineLazyInternal(inst, "propValues", (zod) => zod.def.innerType._zod.propValues);
defineLazyInternal(inst, "values", (zod) => zod.def.innerType._zod.values);
defineLazyInternal(inst, "optin", (zod) => zod.def.innerType?._zod?.optin);
defineLazyInternal(inst, "optout", (zod) => zod.def.innerType?._zod?.optout);
inst._zod.parse = (payload, ctx) => {
if (ctx.direction === "backward") return def.innerType._zod.run(payload, ctx);
const result = def.innerType._zod.run(payload, ctx);
if (result instanceof Promise) return result.then(handleReadonlyResult);
return handleReadonlyResult(result);
};
});
function handleReadonlyResult(payload) {
if (!payload.memo) payload.value = Object.freeze(payload.value);
return payload;
}
const $ZodCustom = /*@__PURE__*/ $constructor("$ZodCustom", (inst, def) => {
$ZodCheck.init(inst, def);
$ZodType.init(inst, def);
inst._zod.parse = (payload, _) => {
return payload;
};
inst._zod.check = (payload) => {
const input = payload.value;
const r = def.fn(input);
if (r instanceof Promise) return r.then((r) => handleRefineResult(r, payload, input, inst));
handleRefineResult(r, payload, input, inst);
};
});
function handleRefineResult(result, payload, input, inst) {
if (!result) {
const _iss = {
code: "custom",
input,
inst,
path: [...inst._zod.def.path ?? []],
continue: !inst._zod.def.abort
};
if (inst._zod.def.params) _iss.params = inst._zod.def.params;
payload.issues.push(issue(_iss));
}
}
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/memoizer.js
var $ZodCyclicError = class extends Error {
constructor() {
super(`Cannot parse a reference cycle that closes through a transform`);
this.name = "ZodCyclicError";
}
};
/** Keyed off the context object every schema in one parse call already shares. */
const STATE = "~memo";
const NO_ISSUES = [];
function isRef(value) {
return value !== null && typeof value === "object";
}
function cloneIssues(issues) {
return issues.map((iss) => iss.path ? {
...iss,
path: iss.path.slice()
} : { ...iss });
}
const recursive = /*@__PURE__*/ new WeakMap();
/** What the walk established, in order of certainty: ordered so the strongest answer among children wins. */
const NONE = 0;
const ASSUMED = 1;
const PROVEN = 2;
/** Whether this schema's subtree contains a cycle, so one parse can re-enter it. */
function isRecursive(inst, stack, resolve) {
const cached = recursive.get(inst);
if (cached !== void 0) return cached ? PROVEN : NONE;
if (stack.has(inst)) return PROVEN;
stack.add(inst);
let result = NONE;
const check = (child) => {
if (result !== PROVEN && child?._zod) {
const answer = isRecursive(child, stack, resolve);
if (answer > result) result = answer;
}
};
const shape = (sh, spread) => {
let answer = NONE;
for (const key of Reflect.ownKeys(sh)) {
const desc = Object.getOwnPropertyDescriptor(sh, key);
if (spread && !desc.enumerable) continue;
const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;
if (child > answer) answer = child;
}
return answer;
};
const merge = (answer) => {
if (answer > result) result = answer;
};
const def = inst._zod.def;
switch (def.type) {
case "object": {
const raw = rawShape(def);
merge(raw ? shape(raw, true) : ASSUMED);
check(def.catchall);
break;
}
case "array":
check(def.element);
break;
case "tuple":
for (const el of def.items) check(el);
check(def.rest);
break;
case "record":
case "map":
check(def.keyType);
check(def.valueType);
break;
case "set":
check(def.valueType);
break;
case "union":
for (const el of def.options) check(el);
break;
case "intersection":
check(def.left);
check(def.right);
break;
case "optional":
case "nullable":
case "default":
case "prefault":
case "catch":
case "readonly":
case "nonoptional":
case "promise":
case "success":
check(def.innerType);
break;
case "pipe":
check(def.in);
check(def.out);
break;
case "function":
check(def.input);
check(def.output);
break;
case "lazy": {
const inner = def._cachedInner ?? (resolve ? inst._zod.innerType : void 0);
merge(inner ? isRecursive(inner, stack, false) : ASSUMED);
break;
}
case "template_literal":
case "string":
case "number":
case "int":
case "boolean":
case "bigint":
case "symbol":
case "undefined":
case "null":
case "void":
case "never":
case "any":
case "unknown":
case "date":
case "nan":
case "enum":
case "literal":
case "file":
case "transform":
case "custom": break;
default: for (const key in def) {
const desc = Object.getOwnPropertyDescriptor(def, key);
if (!desc || desc.get) continue;
const value = desc.value;
if (!value || typeof value !== "object") continue;
if (value._zod) check(value);
else if (Array.isArray(value)) for (const el of value) check(el);
}
}
stack.delete(inst);
return settle(inst, result);
}
/** An assumed answer must not outlive the resolution that settles it, so only a certain one is cached. */
function settle(inst, answer) {
if (answer !== ASSUMED) recursive.set(inst, answer === PROVEN);
return answer;
}
function bucketFor(state, inst) {
let bucket = state.buckets.get(inst);
if (!bucket) {
bucket = /* @__PURE__ */ new WeakMap();
state.buckets.set(inst, bucket);
}
return bucket;
}
let handoff;
const open = [];
const memo = {
alloc(_inst, payload, empty) {
const bucket = handoff;
if (!bucket) return empty;
handoff = void 0;
const entry = {
value: empty,
issues: null
};
bucket.set(payload.value, entry);
open.push(entry);
return empty;
},
guard(inst) {
var _a;
(_a = inst._zod).deferred ?? (_a.deferred = []);
inst._zod.deferred.push(() => {
const base = inst._zod.parse;
const wrapped = (payload, ctx) => {
if (ctx.direction !== "backward" && isBackEdge(ctx, payload.value)) throw new $ZodCyclicError();
return base(payload, ctx);
};
inst._zod.parse = wrapped;
if (inst._zod.run === base) inst._zod.run = wrapped;
});
},
attach(inst) {
var _a;
let isRecursiveInst;
let rechecked = false;
let lastCtx;
let lastBucket;
(_a = inst._zod).deferred ?? (_a.deferred = []);
inst._zod.deferred.push(() => {
const base = inst._zod.parse;
const wrapped = (payload, ctx) => {
if (isRecursiveInst === void 0) {
const walked = isRecursive(inst, /* @__PURE__ */ new Set(), false);
if (walked === NONE) {
inst._zod.parse = base;
if (inst._zod.run === wrapped) inst._zod.run = base;
return base(payload, ctx);
}
if (walked === PROVEN || rechecked) isRecursiveInst = true;
else rechecked = true;
}
const input = payload.value;
if (!isRef(input)) return base(payload, ctx);
let state = ctx[STATE];
if (!state) {
state = {
buckets: /* @__PURE__ */ new WeakMap(),
backEdges: void 0
};
ctx[STATE] = state;
}
let bucket;
if (lastCtx === ctx) bucket = lastBucket;
else {
bucket = bucketFor(state, inst);
lastCtx = ctx;
lastBucket = bucket;
}
const hit = bucket.get(input);
if (hit) {
payload.value = hit.value;
if (hit.issues) {
if (hit.issues.length) payload.issues.push(...cloneIssues(hit.issues));
} else {
payload.memo = true;
state.backEdges ?? (state.backEdges = /* @__PURE__ */ new WeakSet());
state.backEdges.add(hit.value);
}
return payload;
}
handoff = bucket;
const depth = open.length;
const result = base(payload, ctx);
handoff = void 0;
const entry = open.length > depth ? open.pop() : void 0;
if (result instanceof Promise) return result.then((r) => {
if (entry) entry.issues = r.issues.length ? cloneIssues(r.issues) : NO_ISSUES;
return r;
});
if (entry) entry.issues = result.issues.length ? cloneIssues(result.issues) : NO_ISSUES;
return result;
};
inst._zod.parse = wrapped;
if (inst._zod.run === base) inst._zod.run = wrapped;
});
}
};
/** The memoizer that gives containers cycle support. `zod` installs it by default; `zod/mini` opts in with `config({ memoizer: memoizer() })`. */
function memoizer() {
return memo;
}
/** Whether this value is a node a back-edge resolved to before it finished. */
function isBackEdge(ctx, value) {
const backEdges = ctx[STATE]?.backEdges;
return backEdges !== void 0 && isRef(value) && backEdges.has(value);
}
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/en.js
const error = () => {
const Sizable = {
string: {
unit: "characters",
verb: "to have"
},
file: {
unit: "bytes",
verb: "to have"
},
array: {
unit: "items",
verb: "to have"
},
set: {
unit: "items",
verb: "to have"
},
map: {
unit: "entries",
verb: "to have"
}
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "input",
email: "email address",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO datetime",
date: "ISO date",
time: "ISO time",
duration: "ISO duration",
ipv4: "IPv4 address",
ipv6: "IPv6 address",
mac: "MAC address",
cidrv4: "IPv4 range",
cidrv6: "IPv6 range",
base64: "base64-encoded string",
base64url: "base64url-encoded string",
json_string: "JSON string",
e164: "E.164 number",
currency_code: "currency code",
credit_card: "credit card number",
iban: "IBAN",
jwt: "JWT",
template_literal: "input"
};
const TypeDictionary = { nan: "NaN" };
function getTypeName(type, input) {
if (type === "number" && typeof input === "number" && !Number.isFinite(input)) return String(input);
return TypeDictionary[type] ?? type;
}
return (issue) => {
switch (issue.code) {
case "invalid_type": return `Invalid input: expected ${getTypeName(issue.expected)}, received ${getTypeName(parsedType(issue.input), issue.input)}`;
case "invalid_value":
if (issue.values.length === 1) return `Invalid input: expected ${stringifyPrimitive(issue.values[0])}`;
return `Invalid option: expected one of ${joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.exact ? "exactly " : issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing) return `Too big: expected ${issue.origin ?? "value"} to have ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elements"}`;
return `Too big: expected ${issue.origin ?? "value"} to be ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.exact ? "exactly " : issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) return `Too small: expected ${issue.origin} to have ${adj}${issue.minimum.toString()} ${sizing.unit}`;
return `Too small: expected ${issue.origin} to be ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") return `Invalid string: must start with "${_issue.prefix}"`;
if (_issue.format === "ends_with") return `Invalid string: must end with "${_issue.suffix}"`;
if (_issue.format === "includes") return `Invalid string: must include "${_issue.includes}"`;
if (_issue.format === "regex") return `Invalid string: must match pattern ${_issue.pattern}`;
return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of": return `Invalid number: must be a multiple of ${issue.divisor}`;
case "unrecognized_keys": return `Unrecognized key${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
case "invalid_key": return `Invalid key in ${issue.origin}`;
case "invalid_union":
if (issue.options && Array.isArray(issue.options) && issue.options.length > 0) return `Invalid discriminator value. Expected ${issue.options.map((o) => `'${o}'`).join(" | ")}`;
if (issue.inclusive === false) return "Invalid input: more than one option matched";
return "Invalid input";
case "invalid_element": return `Invalid value in ${issue.origin}`;
default: return `Invalid input`;
}
};
};
function en_default() {
return { localeError: error() };
}
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/registries.js
var _a;
var $ZodRegistry = class {
constructor() {
this._map = /* @__PURE__ */ new WeakMap();
this._idmap = /* @__PURE__ */ new Map();
}
add(schema, ..._meta) {
const meta = _meta[0];
this._map.set(schema, meta);
if (meta && typeof meta === "object" && "id" in meta) this._idmap.set(meta.id, schema);
return this;
}
clear() {
this._map = /* @__PURE__ */ new WeakMap();
this._idmap = /* @__PURE__ */ new Map();
return this;
}
remove(schema) {
const meta = this._map.get(schema);
if (meta && typeof meta === "object" && "id" in meta) this._idmap.delete(meta.id);
this._map.delete(schema);
return this;
}
get(schema) {
const p = schema._zod.parent;
if (p) {
const pm = { ...this.get(p) ?? {} };
delete pm.id;
const f = {
...pm,
...this._map.get(schema)
};
return Object.keys(f).length ? f : void 0;
}
return this._map.get(schema);
}
has(schema) {
return this._map.has(schema);
}
};
function registry() {
return new $ZodRegistry();
}
(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
const globalRegistry = globalThis.__zod_globalRegistry;
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/api.js
function snapshotChecks(def) {
if (def.checks) def.checks = [...def.checks];
return def;
}
// @__NO_SIDE_EFFECTS__
function _string(Class, params) {
return new Class(snapshotChecks({
type: "string",
...normalizeParams(params)
}));
}
// @__NO_SIDE_EFFECTS__
function _email(Class, params) {
return new Class({
type: "string",
format: "email",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _guid(Class, params) {
return new Class({
type: "string",
format: "guid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _uuid(Class, params) {
return new Class({
type: "string",
format: "uuid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _uuidv4(Class, params) {
return new Class({
type: "string",
format: "uuid",
check: "string_format",
abort: false,
version: "v4",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _uuidv6(Class, params) {
return new Class({
type: "string",
format: "uuid",
check: "string_format",
abort: false,
version: "v6",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _uuidv7(Class, params) {
return new Class({
type: "string",
format: "uuid",
check: "string_format",
abort: false,
version: "v7",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _url(Class, params) {
return new Class({
type: "string",
format: "url",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _emoji(Class, params) {
return new Class({
type: "string",
format: "emoji",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _nanoid(Class, params) {
return new Class({
type: "string",
format: "nanoid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
/**
* @deprecated CUID v1 is deprecated by its authors due to information leakage
* (timestamps embedded in the id). Use {@link _cuid2} instead.
* See https://github.com/paralleldrive/cuid.
*/
// @__NO_SIDE_EFFECTS__
function _cuid(Class, params) {
return new Class({
type: "string",
format: "cuid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _cuid2(Class, params) {
return new Class({
type: "string",
format: "cuid2",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _ulid(Class, params) {
return new Class({
type: "string",
format: "ulid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _xid(Class, params) {
return new Class({
type: "string",
format: "xid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _ksuid(Class, params) {
return new Class({
type: "string",
format: "ksuid",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _ipv4(Class, params) {
return new Class({
type: "string",
format: "ipv4",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _ipv6(Class, params) {
return new Class({
type: "string",
format: "ipv6",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _cidrv4(Class, params) {
return new Class({
type: "string",
format: "cidrv4",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _cidrv6(Class, params) {
return new Class({
type: "string",
format: "cidrv6",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _base64(Class, params) {
return new Class({
type: "string",
format: "base64",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _base64url(Class, params) {
return new Class({
type: "string",
format: "base64url",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _e164(Class, params) {
return new Class({
type: "string",
format: "e164",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _jwt(Class, params) {
return new Class({
type: "string",
format: "jwt",
check: "string_format",
abort: false,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _isoDateTime(Class, params) {
return new Class({
type: "string",
format: "datetime",
check: "string_format",
offset: false,
local: false,
precision: null,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _isoDate(Class, params) {
return new Class({
type: "string",
format: "date",
check: "string_format",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _isoTime(Class, params) {
return new Class({
type: "string",
format: "time",
check: "string_format",
precision: null,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _isoDuration(Class, params) {
return new Class({
type: "string",
format: "duration",
check: "string_format",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _number(Class, params) {
return new Class(snapshotChecks({
type: "number",
checks: [],
...normalizeParams(params)
}));
}
// @__NO_SIDE_EFFECTS__
function _int(Class, params) {
return new Class({
type: "number",
check: "number_format",
abort: false,
format: "safeint",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _boolean(Class, params) {
return new Class({
type: "boolean",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _unknown(Class) {
return new Class({ type: "unknown" });
}
// @__NO_SIDE_EFFECTS__
function _never(Class, params) {
return new Class({
type: "never",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _lt(value, params) {
return new $ZodCheckLessThan({
check: "less_than",
...normalizeParams(params),
value,
inclusive: false
});
}
// @__NO_SIDE_EFFECTS__
function _lte(value, params) {
return new $ZodCheckLessThan({
check: "less_than",
...normalizeParams(params),
value,
inclusive: true
});
}
// @__NO_SIDE_EFFECTS__
function _gt(value, params) {
return new $ZodCheckGreaterThan({
check: "greater_than",
...normalizeParams(params),
value,
inclusive: false
});
}
// @__NO_SIDE_EFFECTS__
function _gte(value, params) {
return new $ZodCheckGreaterThan({
check: "greater_than",
...normalizeParams(params),
value,
inclusive: true
});
}
// @__NO_SIDE_EFFECTS__
function _multipleOf(value, params) {
return new $ZodCheckMultipleOf({
check: "multiple_of",
...normalizeParams(params),
value
});
}
// @__NO_SIDE_EFFECTS__
function _maxLength(maximum, params) {
return new $ZodCheckMaxLength({
check: "max_length",
...normalizeParams(params),
maximum
});
}
// @__NO_SIDE_EFFECTS__
function _minLength(minimum, params) {
return new $ZodCheckMinLength({
check: "min_length",
...normalizeParams(params),
minimum
});
}
// @__NO_SIDE_EFFECTS__
function _length(length, params) {
return new $ZodCheckLengthEquals({
check: "length_equals",
...normalizeParams(params),
length
});
}
// @__NO_SIDE_EFFECTS__
function _regex(pattern, params) {
return new $ZodCheckRegex({
check: "string_format",
format: "regex",
...normalizeParams(params),
pattern
});
}
// @__NO_SIDE_EFFECTS__
function _lowercase(params) {
return new $ZodCheckLowerCase({
check: "string_format",
format: "lowercase",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _uppercase(params) {
return new $ZodCheckUpperCase({
check: "string_format",
format: "uppercase",
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _includes(includes, params) {
return new $ZodCheckIncludes({
check: "string_format",
format: "includes",
...normalizeParams(params),
includes
});
}
// @__NO_SIDE_EFFECTS__
function _startsWith(prefix, params) {
return new $ZodCheckStartsWith({
check: "string_format",
format: "starts_with",
...normalizeParams(params),
prefix
});
}
// @__NO_SIDE_EFFECTS__
function _endsWith(suffix, params) {
return new $ZodCheckEndsWith({
check: "string_format",
format: "ends_with",
...normalizeParams(params),
suffix
});
}
// @__NO_SIDE_EFFECTS__
function _overwrite(tx) {
return new $ZodCheckOverwrite({
check: "overwrite",
tx
});
}
// @__NO_SIDE_EFFECTS__
function _normalize(form) {
return /* @__PURE__ */ _overwrite((input) => input.normalize(form));
}
// @__NO_SIDE_EFFECTS__
function _trim() {
return /* @__PURE__ */ _overwrite((input) => input.trim());
}
// @__NO_SIDE_EFFECTS__
function _toLowerCase() {
return /* @__PURE__ */ _overwrite((input) => input.toLowerCase());
}
// @__NO_SIDE_EFFECTS__
function _toUpperCase() {
return /* @__PURE__ */ _overwrite((input) => input.toUpperCase());
}
// @__NO_SIDE_EFFECTS__
function _slugify() {
return /* @__PURE__ */ _overwrite((input) => slugify(input));
}
// @__NO_SIDE_EFFECTS__
function _array(Class, element, params) {
return new Class({
type: "array",
element,
...normalizeParams(params)
});
}
// @__NO_SIDE_EFFECTS__
function _custom(Class, fn, _params) {
const norm = normalizeParams(_params);
norm.abort ?? (norm.abort = true);
return new Class({
type: "custom",
check: "custom",
fn,
...norm
});
}
// @__NO_SIDE_EFFECTS__
function _refine(Class, fn, _params) {
return new Class({
type: "custom",
check: "custom",
fn,
...normalizeParams(_params)
});
}
// @__NO_SIDE_EFFECTS__
function _superRefine(fn, params) {
const ch = /* @__PURE__ */ _check((payload) => {
payload.addIssue = (issue$2) => {
if (typeof issue$2 === "string") payload.issues.push(issue(issue$2, payload.value, ch._zod.def));
else {
const _issue = issue$2;
if (_issue.fatal) _issue.continue = false;
_issue.code ?? (_issue.code = "custom");
if (!("input" in _issue)) _issue.input = payload.value;
_issue.inst ?? (_issue.inst = ch);
_issue.continue ?? (_issue.continue = !ch._zod.def.abort);
payload.issues.push(issue(_issue));
}
};
return fn(payload.value, payload);
}, params);
return ch;
}
// @__NO_SIDE_EFFECTS__
function _check(fn, params) {
const ch = new $ZodCheck({
check: "custom",
...normalizeParams(params)
});
ch._zod.check = fn;
return ch;
}
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/to-json-schema.js
function assignProps(target, ...sources) {
for (const source of sources) for (const key of Reflect.ownKeys(source)) if (Object.prototype.propertyIsEnumerable.call(source, key)) assignProp(target, key, source[key]);
return target;
}
function initializeContext(params) {
let target = params?.target ?? "draft-2020-12";
if (target === "draft-4") target = "draft-04";
if (target === "draft-7") target = "draft-07";
return {
processors: params.processors ?? {},
metadataRegistry: params?.metadata ?? globalRegistry,
target,
unrepresentable: params?.unrepresentable ?? "throw",
override: params?.override ?? (() => {}),
io: params?.io ?? "output",
counter: 0,
seen: /* @__PURE__ */ new Map(),
sharedDefsExtractedFor: void 0,
sharedEmitDoneFor: void 0,
cycles: params?.cycles ?? "ref",
reused: params?.reused ?? "inline",
intersections: [],
deferred: [],
external: params?.external ?? void 0
};
}
/**
* Applies the `unrepresentable` setting at a site that has no JSON Schema equivalent. Throws
* `message` unless the setting (or the handler's return value) says otherwise. Returns `true` if a
* custom JSON Schema was written into `json`, in which case the caller must not write its own.
*/
function handleUnrepresentable(schema, ctx, json, params, message) {
const result = typeof ctx.unrepresentable === "function" ? ctx.unrepresentable({
zodSchema: schema,
path: params.path,
message
}) : ctx.unrepresentable;
if (result === "any") return false;
if (result === void 0 || result === "throw") throw new Error(message);
Object.assign(json, result);
return true;
}
function processSchema(schema, ctx, _params = {
path: [],
schemaPath: []
}) {
var _a;
const def = schema._zod.def;
const seen = ctx.seen.get(schema);
if (seen) {
seen.count++;
if (_params.schemaPath.includes(schema)) seen.cycle = _params.path;
return seen.schema;
}
const result = {
schema: {},
count: 1,
cycle: void 0,
path: _params.path
};
ctx.seen.set(schema, result);
ctx.sharedDefsExtractedFor = void 0;
ctx.sharedEmitDoneFor = void 0;
const overrideSchema = schema._zod.toJSONSchema?.();
if (overrideSchema) result.schema = overrideSchema;
else {
const params = {
..._params,
schemaPath: [..._params.schemaPath, schema],
path: _params.path
};
if (schema._zod.processJSONSchema) schema._zod.processJSONSchema(ctx, result.schema, params);
else {
const _json = result.schema;
const processor = ctx.processors[def.type];
if (!processor) throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
processor(schema, ctx, _json, params);
}
const parent = schema._zod.parent;
if (parent) {
if (!result.ref) result.ref = parent;
processSchema(parent, ctx, params);
ctx.seen.get(parent).isParent = true;
}
}
const meta = ctx.metadataRegistry.get(schema);
if (meta) assignProps(result.schema, meta);
if (ctx.io === "input" && isTransforming(schema)) {
delete result.schema.examples;
delete result.schema.default;
}
if (ctx.io === "input" && "_prefault" in result.schema) (_a = result.schema).default ?? (_a.default = result.schema._prefault);
delete result.schema._prefault;
return ctx.seen.get(schema).schema;
}
function encodeJSONPointerSegment(segment) {
return segment.replace(/~/g, "~0").replace(/\//g, "~1");
}
function extractDefs(ctx, schema) {
const root = ctx.seen.get(schema);
if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
if (ctx.external && ctx.sharedDefsExtractedFor === ctx.external) return;
const idToSchema = /* @__PURE__ */ new Map();
for (const entry of ctx.seen.entries()) {
const id = ctx.metadataRegistry.get(entry[0])?.id;
if (id) {
const existing = idToSchema.get(id);
if (existing && existing !== entry[0]) throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
idToSchema.set(id, entry[0]);
}
}
const makeURI = (entry) => {
const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
if (ctx.external) {
const externalId = ctx.external.registry.get(entry[0])?.id;
const uriGenerator = ctx.external.uri ?? ((id) => id);
if (externalId) return { ref: uriGenerator(externalId) };
const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
entry[1].defId = id;
return {
defId: id,
ref: `${uriGenerator("__shared")}#/${defsSegment}/${encodeJSONPointerSegment(id)}`
};
}
const uriPrefix = `#`;
const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
if (entry[1] === root && !entry[1].schema.id) return { ref: uriPrefix };
const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
return {
defId,
ref: defUriPrefix + encodeJSONPointerSegment(defId)
};
};
const extractToDef = (entry) => {
if (entry[1].schema.$ref) return;
const seen = entry[1];
const { ref, defId } = makeURI(entry);
seen.def = { ...seen.schema };
if (defId) seen.defId = defId;
const schema = seen.schema;
for (const key in schema) delete schema[key];
schema.$ref = ref;
};
if (ctx.cycles === "throw") for (const entry of ctx.seen.entries()) {
const seen = entry[1];
if (seen.cycle) throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
}
for (const entry of ctx.seen.entries()) {
const seen = entry[1];
if (schema === entry[0]) {
extractToDef(entry);
continue;
}
if (ctx.external) {
const ext = ctx.external.registry.get(entry[0])?.id;
if (schema !== entry[0] && ext) {
extractToDef(entry);
continue;
}
}
if (ctx.metadataRegistry.get(entry[0])?.id) {
extractToDef(entry);
continue;
}
if (seen.cycle) {
extractToDef(entry);
continue;
}
if (seen.count > 1) {
if (ctx.reused === "ref") extractToDef(entry);
}
}
if (ctx.external) ctx.sharedDefsExtractedFor = ctx.external;
}
/** Rewrites `anyOf: [{type: "a"}, {type: "b"}]` to `type: ["a", "b"]`, which every JSON Schema draft treats as equivalent and most consumers render far better for the nullable case. Only branches that are a bare type assertion qualify — anything carrying a constraint, `$ref`, `const` or metadata is left alone. Runs after `flattenRef`, so a branch an override decorated or `$defs` extraction turned into a `$ref` is no longer bare and correctly stays in `anyOf`. `oneOf` is excluded: `integer` and `number` overlap, so "exactly one" and "at least one" are not the same there. OpenAPI 3.0 is excluded: its `type` must be a single string. */
function compactTypeUnion(schema) {
const options = schema.anyOf;
if (!Array.isArray(options) || options.length === 0 || schema.type !== void 0) return;
const types = [];
for (const option of options) {
if (!option || typeof option !== "object") return;
compactTypeUnion(option);
const keys = Object.keys(option);
if (keys.length !== 1 || keys[0] !== "type") return;
const type = option.type;
for (const member of Array.isArray(type) ? type : [type]) {
if (typeof member !== "string") return;
if (!types.includes(member)) types.push(member);
}
}
delete schema.anyOf;
schema.type = types.length === 1 ? types[0] : types;
}
/** Keywords `foldIntersection` knows how to combine. Anything else — `$ref`, `patternProperties`,
* an annotation like `description` — makes a member unfoldable, so a constraint this does not
* understand leaves the `allOf` alone instead of being silently dropped or misattributed. */
const FOLDABLE_KEYS = /* @__PURE__ */ new Set([
"type",
"properties",
"required",
"additionalProperties"
]);
const UNION_KEYS = ["oneOf", "anyOf"];
/** A member's constraint on a key it does not declare itself. A `catchall` states one; `false`, an absent `additionalProperties`, and the empty schema a loose object emits state nothing. */
function undeclaredConstraint(member) {
const extra = member.additionalProperties;
if (extra === void 0 || extra === false || typeof extra !== "object" || extra === null) return null;
return Object.keys(extra).length ? extra : null;
}
/** Combines object members into the single object they describe together, or returns `null` if any of them carries a keyword outside {@link FOLDABLE_KEYS}. */
function foldObjects(members) {
const objects = [];
for (const member of members) {
if (typeof member !== "object" || member.type !== "object") return null;
for (const key in member) if (!FOLDABLE_KEYS.has(key)) return null;
objects.push(member);
}
const properties = {};
const required = /* @__PURE__ */ new Set();
for (const object of objects) {
for (const key in object.properties) {
if (Object.prototype.hasOwnProperty.call(properties, key)) continue;
const parts = [];
for (const other of objects) {
const part = other.properties?.[key] ?? undeclaredConstraint(other);
if (part === null || part === void 0) continue;
if (!parts.some((seen) => JSON.stringify(seen) === JSON.stringify(part))) parts.push(part);
}
assignProp(properties, key, parts.length === 1 ? parts[0] : foldObjects(parts) ?? { allOf: parts });
}
for (const key of object.required ?? []) required.add(key);
}
const folded = {
type: "object",
properties
};
if (required.size) folded.required = [...required];
if (objects.every((object) => object.additionalProperties === false)) folded.additionalProperties = false;
else {
const constraints = [];
for (const object of objects) {
const constraint = undeclaredConstraint(object);
if (constraint && !constraints.some((seen) => JSON.stringify(seen) === JSON.stringify(constraint))) constraints.push(constraint);
}
if (constraints.length === 1) folded.additionalProperties = constraints[0];
else if (constraints.length > 1) folded.additionalProperties = { allOf: constraints };
}
return folded;
}
/** `additionalProperties` in an `allOf` member sees only that member's own `properties`, so two
* closed object members reject each other's keys and the schema validates nothing. Zod's parser
* pools the key sets instead — `handleIntersectionResults` reports a key as unrecognized only when
* *every* side rejects it — so the emitted schema has to pool them too, and folding the members
* into one object is the encoding that says so on every target.
*
* This runs from `finalize`, after `extractDefs`, which is what keeps it clear of the `$ref`
* machinery: a member extracted into `$defs` is already a `$ref` by now and declines to fold, so it
* keeps its reference and its own closedness rather than being inlined as a stale copy. */
function foldIntersection(json) {
const allOf = json.allOf;
if (!Array.isArray(allOf) || allOf.length < 2) return;
for (const key of FOLDABLE_KEYS) if (key in json) return;
const unions = allOf.filter((m) => UNION_KEYS.some((k) => Array.isArray(m[k])));
let folded = null;
if (!unions.length) folded = foldObjects(allOf);
else {
const union = unions[0];
const keyword = UNION_KEYS.find((k) => Array.isArray(union[k]));
if (Object.keys(union).length !== 1) return;
const rest = allOf.filter((m) => m !== union);
const branches = union[keyword].map((branch) => foldObjects([...rest, branch]));
if (branches.some((b) => !b)) return;
folded = { [keyword]: branches };
}
if (!folded) return;
delete json.allOf;
assignProps(json, folded);
}
function finalize(ctx, schema) {
const root = ctx.seen.get(schema);
if (!root) throw new Error("Unprocessed schema. This is a bug in Zod.");
const flattenRef = (zodSchema) => {
const seen = ctx.seen.get(zodSchema);
if (seen.ref === null) return;
const schema = seen.def ?? seen.schema;
const _cached = { ...schema };
const ref = seen.ref;
seen.ref = null;
if (ref) {
flattenRef(ref);
const refSeen = ctx.seen.get(ref);
const refSchema = refSeen.schema;
if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
schema.allOf = schema.allOf ?? [];
schema.allOf.push(refSchema);
} else assignProps(schema, refSchema);
assignProps(schema, _cached);
if (zodSchema._zod.parent === ref) for (const key in schema) {
if (key === "$ref" || key === "allOf") continue;
if (!(key in _cached)) delete schema[key];
}
if (refSchema.$ref && refSeen.def) for (const key in schema) {
if (key === "$ref" || key === "allOf") continue;
if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) delete schema[key];
}
}
const parent = zodSchema._zod.parent;
if (parent && parent !== ref) {
flattenRef(parent);
const parentSeen = ctx.seen.get(parent);
if (parentSeen?.schema.$ref) {
schema.$ref = parentSeen.schema.$ref;
if (parentSeen.def) for (const key in schema) {
if (key === "$ref" || key === "allOf") continue;
if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) delete schema[key];
}
}
}
ctx.override({
zodSchema,
jsonSchema: schema,
path: seen.path ?? []
});
};
if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) {
for (const entry of [...ctx.seen.entries()].reverse()) flattenRef(entry[0]);
if (ctx.target !== "openapi-3.0") for (const entry of ctx.seen.entries()) compactTypeUnion(entry[1].def ?? entry[1].schema);
for (const rewrite of ctx.deferred) rewrite();
if (ctx.intersections.length) {
const carriers = /* @__PURE__ */ new Map();
for (const seen of ctx.seen.values()) for (const json of [seen.schema, seen.def]) {
const allOf = json?.allOf;
if (!Array.isArray(allOf)) continue;
const existing = carriers.get(allOf);
if (existing) existing.push(json);
else carriers.set(allOf, [json]);
}
for (const allOf of ctx.intersections) for (const json of carriers.get(allOf) ?? []) foldIntersection(json);
}
}
const result = {};
if (ctx.target === "draft-2020-12") result.$schema = "https://json-schema.org/draft/2020-12/schema";
else if (ctx.target === "draft-07") result.$schema = "http://json-schema.org/draft-07/schema#";
else if (ctx.target === "draft-04") result.$schema = "http://json-schema.org/draft-04/schema#";
else if (ctx.target === "openapi-3.0") {}
if (ctx.external?.uri) {
const id = ctx.external.registry.get(schema)?.id;
if (!id) throw new Error("Schema is missing an `id` property");
result.$id = ctx.external.uri(id);
}
assignProps(result, root.defId ? root.schema : root.def ?? root.schema);
const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
if (rootMetaId !== void 0 && result.id === rootMetaId) delete result.id;
const defs = ctx.external?.defs ?? {};
if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) for (const entry of ctx.seen.entries()) {
const seen = entry[1];
if (seen.def && seen.defId) {
if (seen.def.id === seen.defId) delete seen.def.id;
assignProp(defs, seen.defId, seen.def);
}
}
if (ctx.external) ctx.sharedEmitDoneFor = ctx.external;
if (ctx.external) {} else if (Object.keys(defs).length > 0) {
if (ctx.target === "draft-2020-12") result.$defs = defs;
else result.definitions = defs;
}
try {
const finalized = JSON.parse(JSON.stringify(result));
Object.defineProperty(finalized, "~standard", {
value: {
...schema["~standard"],
jsonSchema: {
input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
}
},
enumerable: false,
writable: false
});
return finalized;
} catch (_err) {
throw new Error("Error converting schema to JSON.");
}
}
function isTransforming(_schema, _ctx) {
const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
if (ctx.seen.has(_schema)) return false;
ctx.seen.add(_schema);
const def = _schema._zod.def;
if (def.type === "transform") return true;
if (def.type === "array") return isTransforming(def.element, ctx);
if (def.type === "set") return isTransforming(def.valueType, ctx);
if (def.type === "lazy") return isTransforming(def.getter(), ctx);
if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault" || def.type === "catch") return isTransforming(def.innerType, ctx);
if (def.type === "intersection") return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
if (def.type === "record" || def.type === "map") return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
if (def.type === "pipe") {
if (_schema._zod.traits.has("$ZodCodec")) return true;
return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
}
if (def.type === "object") {
for (const key in def.shape) if (isTransforming(def.shape[key], ctx)) return true;
return false;
}
if (def.type === "union") {
for (const option of def.options) if (isTransforming(option, ctx)) return true;
return false;
}
if (def.type === "tuple") {
for (const item of def.items) if (isTransforming(item, ctx)) return true;
if (def.rest && isTransforming(def.rest, ctx)) return true;
return false;
}
return false;
}
/**
* Creates a toJSONSchema method for a schema instance.
* This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.
*/
const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
const ctx = initializeContext({
...params,
processors
});
processSchema(schema, ctx);
extractDefs(ctx, schema);
return finalize(ctx, schema);
};
const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
const { libraryOptions, target } = params ?? {};
const ctx = initializeContext({
...libraryOptions ?? {},
target,
io,
processors
});
processSchema(schema, ctx);
extractDefs(ctx, schema);
return finalize(ctx, schema);
};
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/json-schema-processors.js
const narrowMin = (agg, key, value) => {
if (agg[key] === void 0 || value > agg[key]) agg[key] = value;
};
const narrowMax = (agg, key, value) => {
if (agg[key] === void 0 || value < agg[key]) agg[key] = value;
};
const narrowBoth = (agg, value) => {
narrowMin(agg, "minimum", value);
narrowMax(agg, "maximum", value);
};
const addDivisor = (agg, value) => {
agg.multipleOf ?? (agg.multipleOf = []);
if (!agg.multipleOf.includes(value)) agg.multipleOf.push(value);
};
const addPattern = (agg, pattern) => {
agg.patterns ?? (agg.patterns = /* @__PURE__ */ new Set());
agg.patterns.add(pattern);
};
const intersectMime = (agg, mime) => {
agg.mime = agg.mime ? agg.mime.filter((m) => mime.includes(m)) : [...mime];
};
const setFormat = (agg, format) => {
agg.format = format;
if (format.includes("int")) agg.isInt = true;
};
const minContributor = (agg, def) => narrowMin(agg, "minimum", def.minimum);
const maxContributor = (agg, def) => narrowMax(agg, "maximum", def.maximum);
const formatContributor = (ranges) => (agg, def) => {
setFormat(agg, def.format);
const [minimum, maximum] = ranges[def.format];
narrowMin(agg, "minimum", minimum);
narrowMax(agg, "maximum", maximum);
};
const contributors = {
greater_than: (agg, def) => narrowMin(agg, def.inclusive ? "minimum" : "exclusiveMinimum", def.value),
less_than: (agg, def) => narrowMax(agg, def.inclusive ? "maximum" : "exclusiveMaximum", def.value),
multiple_of: (agg, def) => addDivisor(agg, def.value),
number_format: formatContributor(NUMBER_FORMAT_RANGES),
bigint_format: formatContributor(BIGINT_FORMAT_RANGES),
min_length: minContributor,
max_length: maxContributor,
length_equals: (agg, def) => narrowBoth(agg, def.length),
min_size: minContributor,
max_size: maxContributor,
size_equals: (agg, def) => narrowBoth(agg, def.size),
string_format: (agg, def) => {
setFormat(agg, def.format);
if (def.pattern) addPattern(agg, def.pattern);
if (def.format === "base64" || def.format === "base64url") agg.contentEncoding = def.format;
if (def.local || def.precision === -1) agg.laxFormat = true;
},
mime_type: (agg, def) => intersectMime(agg, def.mime)
};
function aggregateChecks(schema) {
const agg = {};
const def = schema._zod.def;
const list = schema._zod.traits.has("$ZodCheck") ? [schema, ...def.checks ?? []] : def.checks ?? [];
for (const ch of list) contributors[ch._zod.def.check]?.(agg, ch._zod.def);
const bag = schema._zod.bag;
if (bag.minimum !== void 0) narrowMin(agg, "minimum", bag.minimum);
if (bag.exclusiveMinimum !== void 0) narrowMin(agg, "exclusiveMinimum", bag.exclusiveMinimum);
if (bag.maximum !== void 0) narrowMax(agg, "maximum", bag.maximum);
if (bag.exclusiveMaximum !== void 0) narrowMax(agg, "exclusiveMaximum", bag.exclusiveMaximum);
if (bag.multipleOf !== void 0) addDivisor(agg, bag.multipleOf);
if (bag.format !== void 0) {
agg.format ?? (agg.format = bag.format);
if (bag.format.includes("int")) agg.isInt = true;
}
if (bag.mime) intersectMime(agg, bag.mime);
for (const pattern of bag.patterns ?? []) addPattern(agg, pattern);
return agg;
}
const formatMap = {
guid: "uuid",
url: "uri",
datetime: "date-time",
json_string: "json-string",
regex: ""
};
const exactPatterns = /* @__PURE__ */ new Map([[base64Charset, base64], [base64urlCharset, base64url]]);
const exactPattern = (p) => exactPatterns.get(p) ?? p;
const stringProcessor = (schema, ctx, _json, _params) => {
const json = _json;
json.type = "string";
const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);
if (typeof minimum === "number") json.minLength = minimum;
if (typeof maximum === "number") json.maxLength = maximum;
if (format) {
json.format = formatMap[format] ?? format;
if (json.format === "") delete json.format;
if (format === "time" || laxFormat) delete json.format;
}
if (contentEncoding) json.contentEncoding = contentEncoding;
if (patterns && patterns.size > 0) {
const patternList = [...patterns].map(exactPattern);
if (patternList.length === 1) json.pattern = patternList[0].source;
else if (patternList.length > 1) json.allOf = [...patternList.map((regex) => ({
...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
pattern: regex.source
}))];
}
};
const numberProcessor = (schema, ctx, _json, params) => {
const json = _json;
const { minimum, maximum, multipleOf, exclusiveMaximum, exclusiveMinimum, isInt } = aggregateChecks(schema);
json.type = isInt ? "integer" : "number";
const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
if (exMin) {
if (legacy) {
json.minimum = exclusiveMinimum;
json.exclusiveMinimum = true;
} else json.exclusiveMinimum = exclusiveMinimum;
} else if (typeof minimum === "number") json.minimum = minimum;
if (exMax) {
if (legacy) {
json.maximum = exclusiveMaximum;
json.exclusiveMaximum = true;
} else json.exclusiveMaximum = exclusiveMaximum;
} else if (typeof maximum === "number") json.maximum = maximum;
if (multipleOf) {
const divisors = /* @__PURE__ */ new Set();
for (const divisor of multipleOf) if (Number.isFinite(divisor) && divisor !== 0) divisors.add(Math.abs(divisor));
else handleUnrepresentable(schema, ctx, json, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
const [first, ...rest] = divisors;
if (first !== void 0) json.multipleOf = first;
if (rest.length) json.allOf = [...json.allOf ?? [], ...rest.map((m) => ({ multipleOf: m }))];
}
};
const booleanProcessor = (_schema, _ctx, json, _params) => {
json.type = "boolean";
};
const neverProcessor = (_schema, _ctx, json, _params) => {
json.not = {};
};
const enumProcessor = (schema, _ctx, json, _params) => {
const def = schema._zod.def;
const values = getEnumValues(def.entries);
if (values.length === 0) {
json.not = {};
return;
}
if (values.every((v) => typeof v === "number")) json.type = "number";
if (values.every((v) => typeof v === "string")) json.type = "string";
json.enum = values;
};
const literalProcessor = (schema, ctx, json, params) => {
const def = schema._zod.def;
if (def.values.length === 0) {
json.not = {};
return;
}
const vals = [];
for (const val of def.values) if (val === void 0) {
if (handleUnrepresentable(schema, ctx, json, params, "Literal `undefined` cannot be represented in JSON Schema")) return;
} else if (typeof val === "bigint") {
if (handleUnrepresentable(schema, ctx, json, params, "BigInt literals cannot be represented in JSON Schema")) return;
vals.push(Number(val));
} else vals.push(val);
if (vals.length === 0) {} else if (vals.length === 1) {
const val = vals[0];
json.type = val === null ? "null" : typeof val;
if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") json.enum = [val];
else json.const = val;
} else {
if (vals.every((v) => typeof v === "number")) json.type = "number";
if (vals.every((v) => typeof v === "string")) json.type = "string";
if (vals.every((v) => typeof v === "boolean")) json.type = "boolean";
if (vals.every((v) => v === null)) json.type = "null";
json.enum = vals;
}
};
const customProcessor = (schema, ctx, json, params) => {
handleUnrepresentable(schema, ctx, json, params, "Custom types cannot be represented in JSON Schema");
};
const transformProcessor = (schema, ctx, json, params) => {
handleUnrepresentable(schema, ctx, json, params, "Transforms cannot be represented in JSON Schema");
};
const arrayProcessor = (schema, ctx, _json, params) => {
const json = _json;
const def = schema._zod.def;
const { minimum, maximum } = aggregateChecks(schema);
if (typeof minimum === "number") json.minItems = minimum;
if (typeof maximum === "number") json.maxItems = maximum;
json.type = "array";
json.items = processSchema(def.element, ctx, {
...params,
path: [...params.path, "items"]
});
};
function inputOptin(schema) {
const def = schema._zod.def;
if (def.type === "pipe" && def.in._zod.traits.has("$ZodTransform")) return inputOptin(def.out);
if (def.type === "catch") return inputOptin(def.innerType);
return schema._zod.optin;
}
const objectProcessor = (schema, ctx, _json, params) => {
const json = _json;
const def = schema._zod.def;
const shape = def.shape;
if (Object.getOwnPropertySymbols(shape).length && handleUnrepresentable(schema, ctx, json, params, "Symbol keys cannot be represented in JSON Schema")) return;
json.type = "object";
json.properties = {};
for (const key in shape) assignProp(json.properties, key, processSchema(shape[key], ctx, {
...params,
path: [
...params.path,
"properties",
key
]
}));
const requiredKeys = [];
for (const key of Object.keys(shape)) {
const field = def.shape[key];
if (ctx.io === "input" ? inputOptin(field) === void 0 : field._zod.optout === void 0) requiredKeys.push(key);
}
if (requiredKeys.length > 0) json.required = requiredKeys;
if (def.catchall?._zod.def.type === "never") json.additionalProperties = false;
else if (!def.catchall) {
if (ctx.io === "output") json.additionalProperties = false;
} else if (def.catchall) json.additionalProperties = processSchema(def.catchall, ctx, {
...params,
path: [...params.path, "additionalProperties"]
});
};
const unionProcessor = (schema, ctx, json, params) => {
const def = schema._zod.def;
const isExclusive = def.inclusive === false;
const options = def.options.map((x, i) => processSchema(x, ctx, {
...params,
path: [
...params.path,
isExclusive ? "oneOf" : "anyOf",
i
]
}));
if (isExclusive) json.oneOf = options;
else json.anyOf = options;
};
const intersectionProcessor = (schema, ctx, json, params) => {
const def = schema._zod.def;
const a = processSchema(def.left, ctx, {
...params,
path: [
...params.path,
"allOf",
0
]
});
const b = processSchema(def.right, ctx, {
...params,
path: [
...params.path,
"allOf",
1
]
});
const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
const allOf = [...isSimpleIntersection(a) ? a.allOf : [a], ...isSimpleIntersection(b) ? b.allOf : [b]];
json.allOf = allOf;
ctx.intersections.push(allOf);
};
const nullableProcessor = (schema, ctx, json, params) => {
const def = schema._zod.def;
const inner = processSchema(def.innerType, ctx, params);
const seen = ctx.seen.get(schema);
if (ctx.target === "openapi-3.0") {
seen.ref = def.innerType;
json.nullable = true;
} else json.anyOf = [inner, { type: "null" }];
};
const nonoptionalProcessor = (schema, ctx, _json, params) => {
const def = schema._zod.def;
processSchema(def.innerType, ctx, params);
const seen = ctx.seen.get(schema);
seen.ref = def.innerType;
};
/** Round-trips a default value through JSON so the emitted schema is guaranteed to be valid JSON.
* A BigInt has no reliable encoding, so it goes through `unrepresentable` like any other
* unrepresentable value. Returns a sentinel when the caller must not write a default of its own. */
const UNREPRESENTABLE_DEFAULT = Symbol();
function serializeDefaultValue(value, schema, ctx, json, params) {
let unrepresentable = false;
const serialized = JSON.stringify(value, (_, val) => {
if (typeof val !== "bigint") return val;
unrepresentable = true;
return null;
});
if (!unrepresentable) return JSON.parse(serialized);
handleUnrepresentable(schema, ctx, json, params, "BigInt defaults cannot be represented in JSON Schema");
return UNREPRESENTABLE_DEFAULT;
}
const defaultProcessor = (schema, ctx, json, params) => {
const def = schema._zod.def;
processSchema(def.innerType, ctx, params);
const seen = ctx.seen.get(schema);
seen.ref = def.innerType;
const value = serializeDefaultValue(def.defaultValue, schema, ctx, json, params);
if (value !== UNREPRESENTABLE_DEFAULT) json.default = value;
};
const prefaultProcessor = (schema, ctx, json, params) => {
const def = schema._zod.def;
processSchema(def.innerType, ctx, params);
const seen = ctx.seen.get(schema);
seen.ref = def.innerType;
if (ctx.io !== "input") return;
const value = serializeDefaultValue(def.defaultValue, schema, ctx, json, params);
if (value !== UNREPRESENTABLE_DEFAULT) json._prefault = value;
};
const catchProcessor = (schema, ctx, json, params) => {
const def = schema._zod.def;
processSchema(def.innerType, ctx, params);
const seen = ctx.seen.get(schema);
seen.ref = def.innerType;
let catchValue;
try {
catchValue = def.catchValue(void 0);
} catch {
handleUnrepresentable(schema, ctx, json, params, "Dynamic catch values are not supported in JSON Schema");
return;
}
json.default = catchValue;
};
const pipeProcessor = (schema, ctx, _json, params) => {
const def = schema._zod.def;
const inIsTransform = def.in._zod.traits.has("$ZodTransform");
const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
processSchema(innerType, ctx, params);
const seen = ctx.seen.get(schema);
seen.ref = innerType;
};
const readonlyProcessor = (schema, ctx, json, params) => {
const def = schema._zod.def;
processSchema(def.innerType, ctx, params);
const seen = ctx.seen.get(schema);
seen.ref = def.innerType;
json.readOnly = true;
};
const optionalProcessor = (schema, ctx, _json, params) => {
const def = schema._zod.def;
processSchema(def.innerType, ctx, params);
const seen = ctx.seen.get(schema);
seen.ref = def.innerType;
};
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/errors.js
const _installedErrorProtos = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
function _lazyMethod(proto, key, make) {
Object.defineProperty(proto, key, {
configurable: true,
enumerable: false,
get() {
const value = make(this);
Object.defineProperty(this, key, {
value,
configurable: true,
writable: true
});
return value;
},
set(value) {
Object.defineProperty(this, key, {
value,
configurable: true,
writable: true
});
}
});
}
const initializer = (inst, issues) => {
$ZodError.init(inst, issues);
inst.name = "ZodError";
const proto = Object.getPrototypeOf(inst);
if (_installedErrorProtos.has(proto)) return;
_installedErrorProtos.add(proto);
_lazyMethod(proto, "format", (self) => (mapper) => formatError(self, mapper));
_lazyMethod(proto, "flatten", (self) => (mapper) => flattenError(self, mapper));
_lazyMethod(proto, "addIssue", (self) => (issue) => {
self.issues.push(issue);
self.message = JSON.stringify(self.issues, jsonStringifyReplacer, 2);
});
_lazyMethod(proto, "addIssues", (self) => (issues) => {
self.issues.push(...issues);
self.message = JSON.stringify(self.issues, jsonStringifyReplacer, 2);
});
Object.defineProperty(proto, "isEmpty", {
configurable: true,
enumerable: false,
get() {
return this.issues.length === 0;
}
});
};
const ZodRealError = /*@__PURE__*/ $constructor("ZodError", initializer, void 0, { Parent: Error });
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/parse.js
const parse$1 = /* @__PURE__ */ _parse(ZodRealError);
const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
const safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
const safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
const encode = /* @__PURE__ */ _encode(ZodRealError);
const decode = /* @__PURE__ */ _decode(ZodRealError);
const encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
const decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
const safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
const safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
const safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
const safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
//#endregion
//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/schemas.js
function _ensureDefaultLocale() {
if (!globalConfig.localeError) config(en_default());
}
function _ensureDefaultMemoizer() {
if (!globalConfig.memoizer) config({ memoizer: memoizer() });
}
const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
_ensureDefaultLocale();
$ZodType.init(inst, def);
inst.def = def;
inst.type = def.type;
return inst;
}, {
check(...chks) {
const def = this.def;
return this.clone(mergeDefs(def, { checks: [...def.checks ?? [], ...chks.map((ch) => typeof ch === "function" ? { _zod: {
check: ch,
def: { check: "custom" },
onattach: []
} } : ch)] }), { parent: true });
},
with(...chks) {
return this.check(...chks);
},
clone(def, params) {
return clone(this, def, params);
},
brand() {
return this;
},
register(reg, meta) {
reg.add(this, meta);
return this;
},
refine(check, params) {
return this.check(refine(check, params));
},
superRefine(refinement, params) {
return this.check(superRefine(refinement, params));
},
overwrite(fn) {
return this.check(/* @__PURE__ */ _overwrite(fn));
},
optional() {
return optional(this);
},
exactOptional() {
return exactOptional(this);
},
nullable() {
return nullable(this);
},
nullish() {
return optional(nullable(this));
},
nonoptional(params) {
return nonoptional(this, params);
},
array() {
return array(this);
},
or(arg) {
return union([this, arg]);
},
and(arg) {
return intersection(this, arg);
},
transform(tx) {
return pipe(this, transform(tx));
},
default(d) {
return _default(this, d);
},
prefault(d) {
return prefault(this, d);
},
catch(params) {
return _catch(this, params);
},
pipe(target) {
return pipe(this, target);
},
readonly() {
return readonly(this);
},
describe(description) {
const cl = this.clone();
globalRegistry.add(cl, { description });
return cl;
},
meta(...args) {
if (args.length === 0) return globalRegistry.get(this);
const cl = this.clone();
globalRegistry.add(cl, args[0]);
return cl;
},
isOptional() {
return this.safeParse(void 0).success;
},
isNullable() {
return this.safeParse(null).success;
},
apply(fn, ...args) {
return args.length === 0 ? fn(this) : fn(this, ...args);
},
get "~standard"() {
return hide(this, "~standard", {
...standardProps(this),
jsonSchema: {
input: createStandardJSONSchemaMethod(this, "input"),
output: createStandardJSONSchemaMethod(this, "output")
}
});
},
set "~standard"(value) {
own(this, "~standard", value);
},
parse: function _parse(data, params) {
return parse$1(this, data, params, { callee: _parse });
},
parseAsync: async function _parseAsync(data, params) {
return await parseAsync(this, data, params, { callee: _parseAsync });
},
safeParse(data, params) {
return safeParse(this, data, params);
},
async safeParseAsync(data, params) {
return safeParseAsync(this, data, params);
},
get spa() {
return this?.safeParseAsync;
},
set spa(value) {
own(this, "spa", value);
},
validate(data, params) {
return validate(this, data, params);
},
validateAsync(data, params) {
return validateAsync$1(this, data, params);
},
encode: function _encode(data, params) {
return encode(this, data, params, { callee: _encode });
},
decode: function _decode(data, params) {
return decode(this, data, params, { callee: _decode });
},
encodeAsync: async function _encodeAsync(data, params) {
return await encodeAsync(this, data, params, { callee: _encodeAsync });
},
decodeAsync: async function _decodeAsync(data, params) {
return await decodeAsync(this, data, params, { callee: _decodeAsync });
},
safeEncode(data, params) {
return safeEncode(this, data, params);
},
safeDecode(data, params) {
return safeDecode(this, data, params);
},
async safeEncodeAsync(data, params) {
return safeEncodeAsync(this, data, params);
},
async safeDecodeAsync(data, params) {
return safeDecodeAsync(this, data, params);
},
toJSONSchema(params) {
return createToJSONSchemaMethod(this, {})(params);
},
get description() {
return globalRegistry.get(this)?.description;
},
get _def() {
return this._zod.def;
}
});
/** @internal */
const _ZodString = /*@__PURE__*/ $constructor("_ZodString", (inst, def) => {
$ZodString.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json, params);
}, /*@__PURE__*/ derived({
format: (inst) => aggregateChecks(inst).format ?? null,
minLength: (inst) => aggregateChecks(inst).minimum ?? null,
maxLength: (inst) => aggregateChecks(inst).maximum ?? null
}, {
regex(...args) {
return this.check(/* @__PURE__ */ _regex(...args));
},
includes(...args) {
return this.check(/* @__PURE__ */ _includes(...args));
},
startsWith(...args) {
return this.check(/* @__PURE__ */ _startsWith(...args));
},
endsWith(...args) {
return this.check(/* @__PURE__ */ _endsWith(...args));
},
min(...args) {
return this.check(/* @__PURE__ */ _minLength(...args));
},
max(...args) {
return this.check(/* @__PURE__ */ _maxLength(...args));
},
length(...args) {
return this.check(/* @__PURE__ */ _length(...args));
},
nonempty(...args) {
return this.check(/* @__PURE__ */ _minLength(1, ...args));
},
lowercase(params) {
return this.check(/* @__PURE__ */ _lowercase(params));
},
uppercase(params) {
return this.check(/* @__PURE__ */ _uppercase(params));
},
trim() {
return this.check(/* @__PURE__ */ _trim());
},
normalize(...args) {
return this.check(/* @__PURE__ */ _normalize(...args));
},
toLowerCase() {
return this.check(/* @__PURE__ */ _toLowerCase());
},
toUpperCase() {
return this.check(/* @__PURE__ */ _toUpperCase());
},
slugify() {
return this.check(/* @__PURE__ */ _slugify());
}
}));
const ZodString = /*@__PURE__*/ $constructor("ZodString", (inst, def) => {
$ZodString.init(inst, def);
_ZodString.init(inst, def);
}, {
email(params) {
return this.check(/* @__PURE__ */ _email(ZodEmail, params));
},
url(params) {
return this.check(/* @__PURE__ */ _url(ZodURL, params));
},
jwt(params) {
return this.check(/* @__PURE__ */ _jwt(ZodJWT, params));
},
emoji(params) {
return this.check(/* @__PURE__ */ _emoji(ZodEmoji, params));
},
guid(params) {
return this.check(/* @__PURE__ */ _guid(ZodGUID, params));
},
uuid(params) {
return this.check(/* @__PURE__ */ _uuid(ZodUUID, params));
},
uuidv4(params) {
return this.check(/* @__PURE__ */ _uuidv4(ZodUUID, params));
},
uuidv6(params) {
return this.check(/* @__PURE__ */ _uuidv6(ZodUUID, params));
},
uuidv7(params) {
return this.check(/* @__PURE__ */ _uuidv7(ZodUUID, params));
},
nanoid(params) {
return this.check(/* @__PURE__ */ _nanoid(ZodNanoID, params));
},
cuid(params) {
return this.check(/* @__PURE__ */ _cuid(ZodCUID, params));
},
cuid2(params) {
return this.check(/* @__PURE__ */ _cuid2(ZodCUID2, params));
},
ulid(params) {
return this.check(/* @__PURE__ */ _ulid(ZodULID, params));
},
base64(params) {
return this.check(/* @__PURE__ */ _base64(ZodBase64, params));
},
base64url(params) {
return this.check(/* @__PURE__ */ _base64url(ZodBase64URL, params));
},
xid(params) {
return this.check(/* @__PURE__ */ _xid(ZodXID, params));
},
ksuid(params) {
return this.check(/* @__PURE__ */ _ksuid(ZodKSUID, params));
},
ipv4(params) {
return this.check(/* @__PURE__ */ _ipv4(ZodIPv4, params));
},
ipv6(params) {
return this.check(/* @__PURE__ */ _ipv6(ZodIPv6, params));
},
cidrv4(params) {
return this.check(/* @__PURE__ */ _cidrv4(ZodCIDRv4, params));
},
cidrv6(params) {
return this.check(/* @__PURE__ */ _cidrv6(ZodCIDRv6, params));
},
e164(params) {
return this.check(/* @__PURE__ */ _e164(ZodE164, params));
},
datetime(params) {
return this.check(/* @__PURE__ */ _isoDateTime(ZodISODateTime, params));
},
date(params) {
return this.check(/* @__PURE__ */ _isoDate(ZodISODate, params));
},
time(params) {
return this.check(/* @__PURE__ */ _isoTime(ZodISOTime, params));
},
duration(params) {
return this.check(/* @__PURE__ */ _isoDuration(ZodISODuration, params));
}
});
function string(params) {
return /* @__PURE__ */ _string(ZodString, params);
}
const ZodStringFormat = /*@__PURE__*/ $constructor("ZodStringFormat", (inst, def) => {
$ZodStringFormat.init(inst, def);
_ZodString.init(inst, def);
});
const ZodISODateTime = /*@__PURE__*/ $constructor("ZodISODateTime", (inst, def) => {
$ZodISODateTime.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodISODate = /*@__PURE__*/ $constructor("ZodISODate", (inst, def) => {
$ZodISODate.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodISOTime = /*@__PURE__*/ $constructor("ZodISOTime", (inst, def) => {
$ZodISOTime.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodISODuration = /*@__PURE__*/ $constructor("ZodISODuration", (inst, def) => {
$ZodISODuration.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodEmail = /*@__PURE__*/ $constructor("ZodEmail", (inst, def) => {
$ZodEmail.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodGUID = /*@__PURE__*/ $constructor("ZodGUID", (inst, def) => {
$ZodGUID.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodUUID = /*@__PURE__*/ $constructor("ZodUUID", (inst, def) => {
$ZodUUID.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodURL = /*@__PURE__*/ $constructor("ZodURL", (inst, def) => {
$ZodURL.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodEmoji = /*@__PURE__*/ $constructor("ZodEmoji", (inst, def) => {
$ZodEmoji.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodNanoID = /*@__PURE__*/ $constructor("ZodNanoID", (inst, def) => {
$ZodNanoID.init(inst, def);
ZodStringFormat.init(inst, def);
});
/**
* @deprecated CUID v1 is deprecated by its authors due to information leakage
* (timestamps embedded in the id). Use {@link ZodCUID2} instead.
* See https://github.com/paralleldrive/cuid.
*/
const ZodCUID = /*@__PURE__*/ $constructor("ZodCUID", (inst, def) => {
$ZodCUID.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodCUID2 = /*@__PURE__*/ $constructor("ZodCUID2", (inst, def) => {
$ZodCUID2.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodULID = /*@__PURE__*/ $constructor("ZodULID", (inst, def) => {
$ZodULID.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodXID = /*@__PURE__*/ $constructor("ZodXID", (inst, def) => {
$ZodXID.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodKSUID = /*@__PURE__*/ $constructor("ZodKSUID", (inst, def) => {
$ZodKSUID.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodIPv4 = /*@__PURE__*/ $constructor("ZodIPv4", (inst, def) => {
$ZodIPv4.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodIPv6 = /*@__PURE__*/ $constructor("ZodIPv6", (inst, def) => {
$ZodIPv6.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodCIDRv4 = /*@__PURE__*/ $constructor("ZodCIDRv4", (inst, def) => {
$ZodCIDRv4.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodCIDRv6 = /*@__PURE__*/ $constructor("ZodCIDRv6", (inst, def) => {
$ZodCIDRv6.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodBase64 = /*@__PURE__*/ $constructor("ZodBase64", (inst, def) => {
$ZodBase64.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodBase64URL = /*@__PURE__*/ $constructor("ZodBase64URL", (inst, def) => {
$ZodBase64URL.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodE164 = /*@__PURE__*/ $constructor("ZodE164", (inst, def) => {
$ZodE164.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodJWT = /*@__PURE__*/ $constructor("ZodJWT", (inst, def) => {
$ZodJWT.init(inst, def);
ZodStringFormat.init(inst, def);
});
const ZodNumber = /*@__PURE__*/ $constructor("ZodNumber", (inst, def) => {
$ZodNumber.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json, params);
inst.isFinite = true;
}, /*@__PURE__*/ derived({
minValue: (inst) => {
const { minimum, exclusiveMinimum } = aggregateChecks(inst);
return Math.max(minimum ?? Number.NEGATIVE_INFINITY, exclusiveMinimum ?? Number.NEGATIVE_INFINITY);
},
maxValue: (inst) => {
const { maximum, exclusiveMaximum } = aggregateChecks(inst);
return Math.min(maximum ?? Number.POSITIVE_INFINITY, exclusiveMaximum ?? Number.POSITIVE_INFINITY);
},
isInt: (inst) => {
const { isInt, multipleOf } = aggregateChecks(inst);
return !!isInt || !!multipleOf?.some(Number.isSafeInteger);
},
format: (inst) => aggregateChecks(inst).format ?? null
}, {
gt(value, params) {
return this.check(/* @__PURE__ */ _gt(value, params));
},
gte(value, params) {
return this.check(/* @__PURE__ */ _gte(value, params));
},
min(value, params) {
return this.check(/* @__PURE__ */ _gte(value, params));
},
lt(value, params) {
return this.check(/* @__PURE__ */ _lt(value, params));
},
lte(value, params) {
return this.check(/* @__PURE__ */ _lte(value, params));
},
max(value, params) {
return this.check(/* @__PURE__ */ _lte(value, params));
},
int(params) {
return this.check(int(params));
},
safe(params) {
return this.check(int(params));
},
positive(params) {
return this.check(/* @__PURE__ */ _gt(0, params));
},
nonnegative(params) {
return this.check(/* @__PURE__ */ _gte(0, params));
},
negative(params) {
return this.check(/* @__PURE__ */ _lt(0, params));
},
nonpositive(params) {
return this.check(/* @__PURE__ */ _lte(0, params));
},
multipleOf(value, params) {
return this.check(/* @__PURE__ */ _multipleOf(value, params));
},
step(value, params) {
return this.check(/* @__PURE__ */ _multipleOf(value, params));
},
finite() {
return this;
}
}));
function number(params) {
return /* @__PURE__ */ _number(ZodNumber, params);
}
const ZodNumberFormat = /*@__PURE__*/ $constructor("ZodNumberFormat", (inst, def) => {
$ZodNumberFormat.init(inst, def);
ZodNumber.init(inst, def);
});
function int(params) {
return /* @__PURE__ */ _int(ZodNumberFormat, params);
}
const ZodBoolean = /*@__PURE__*/ $constructor("ZodBoolean", (inst, def) => {
$ZodBoolean.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json, params);
});
function boolean(params) {
return /* @__PURE__ */ _boolean(ZodBoolean, params);
}
const ZodUnknown = /*@__PURE__*/ $constructor("ZodUnknown", (inst, def) => {
$ZodUnknown.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => void 0;
});
function unknown() {
return /* @__PURE__ */ _unknown(ZodUnknown);
}
const ZodNever = /*@__PURE__*/ $constructor("ZodNever", (inst, def) => {
$ZodNever.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params);
});
function never(params) {
return /* @__PURE__ */ _never(ZodNever, params);
}
const ZodArray = /*@__PURE__*/ $constructor("ZodArray", (inst, def) => {
_ensureDefaultMemoizer();
$ZodArray.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params);
inst.element = def.element;
}, {
min(n, params) {
return this.check(/* @__PURE__ */ _minLength(n, params));
},
nonempty(params) {
return this.check(/* @__PURE__ */ _minLength(1, params));
},
max(n, params) {
return this.check(/* @__PURE__ */ _maxLength(n, params));
},
length(n, params) {
return this.check(/* @__PURE__ */ _length(n, params));
},
unwrap() {
return this.element;
}
});
function array(element, params) {
return /* @__PURE__ */ _array(ZodArray, element, params);
}
const ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
_ensureDefaultMemoizer();
$ZodObjectJIT.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);
installLazyProp(inst, "shape", (self) => self._zod.def.shape, false);
}, {
keyof() {
return _enum(Object.keys(this._zod.def.shape));
},
catchall(catchall) {
return this.clone(mergeDefs(this._zod.def, { catchall }));
},
passthrough() {
return this.clone(mergeDefs(this._zod.def, { catchall: unknown() }));
},
loose() {
return this.clone(mergeDefs(this._zod.def, { catchall: unknown() }));
},
strict() {
return this.clone(mergeDefs(this._zod.def, { catchall: never() }));
},
strip() {
return this.clone(mergeDefs(this._zod.def, { catchall: void 0 }));
},
extend(incoming) {
return extend(this, incoming);
},
safeExtend(incoming) {
return safeExtend(this, incoming);
},
merge(other) {
return merge(this, other);
},
pick(mask) {
return pick(this, mask);
},
omit(mask) {
return omit(this, mask);
},
partial(...args) {
return partial(ZodOptional, this, args[0]);
},
exactPartial(...args) {
return partial(ZodExactOptional, this, args[0], "exactPartial");
},
required(...args) {
return required(ZodNonOptional, this, args[0]);
}
});
function object(shape, params) {
const def = {
type: "object",
shape: shape ?? {},
...normalizeParams(params)
};
return new ZodObject(def);
}
function looseObject(shape, params) {
return new ZodObject({
type: "object",
shape,
catchall: unknown(),
...normalizeParams(params)
});
}
const ZodUnion = /*@__PURE__*/ $constructor("ZodUnion", (inst, def) => {
$ZodUnion.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);
inst.options = def.options;
});
function union(options, params) {
return new ZodUnion({
type: "union",
options,
...normalizeParams(params)
});
}
const ZodIntersection = /*@__PURE__*/ $constructor("ZodIntersection", (inst, def) => {
$ZodIntersection.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params);
});
function intersection(left, right) {
return new ZodIntersection({
type: "intersection",
left,
right
});
}
const ZodEnum = /*@__PURE__*/ $constructor("ZodEnum", (inst, def) => {
$ZodEnum.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json, params);
inst.enum = def.entries;
inst.options = [...inst._zod.values];
const keys = new Set(Object.keys(def.entries));
inst.extract = (values, params) => {
const newEntries = {};
for (const value of values) if (keys.has(value)) newEntries[value] = def.entries[value];
else throw new Error(`Key ${value} not found in enum`);
return new ZodEnum({
...def,
checks: [],
...normalizeParams(params),
entries: newEntries
});
};
inst.exclude = (values, params) => {
const newEntries = { ...def.entries };
for (const value of values) if (keys.has(value)) delete newEntries[value];
else throw new Error(`Key ${value} not found in enum`);
return new ZodEnum({
...def,
checks: [],
...normalizeParams(params),
entries: newEntries
});
};
});
function _enum(values, params) {
const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
return new ZodEnum({
type: "enum",
entries,
...normalizeParams(params)
});
}
const ZodLiteral = /*@__PURE__*/ $constructor("ZodLiteral", (inst, def) => {
$ZodLiteral.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => literalProcessor(inst, ctx, json, params);
inst.values = new Set(def.values);
Object.defineProperty(inst, "value", { get() {
if (def.values.length > 1) throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
return def.values[0];
} });
});
function literal(value, params) {
return new ZodLiteral({
type: "literal",
values: Array.isArray(value) ? value : [value],
...normalizeParams(params)
});
}
const ZodTransform = /*@__PURE__*/ $constructor("ZodTransform", (inst, def) => {
_ensureDefaultMemoizer();
$ZodTransform.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx, json, params);
inst._zod.parse = (payload, _ctx) => {
if (_ctx.direction === "backward") throw new $ZodEncodeError(inst.constructor.name);
payload.addIssue = (issue$1) => {
if (typeof issue$1 === "string") payload.issues.push(issue(issue$1, payload.value, def));
else {
const _issue = issue$1;
if (_issue.fatal) _issue.continue = false;
_issue.code ?? (_issue.code = "custom");
if (!("input" in _issue)) _issue.input = payload.value;
_issue.inst ?? (_issue.inst = inst);
payload.issues.push(issue(_issue));
}
};
const output = def.transform(payload.value, payload);
if (output instanceof Promise) return output.then((output) => {
payload.value = output;
return payload;
});
payload.value = output;
return payload;
};
});
function transform(fn) {
return new ZodTransform({
type: "transform",
transform: fn
});
}
const ZodOptional = /*@__PURE__*/ $constructor("ZodOptional", (inst, def) => {
$ZodOptional.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
inst.unwrap = () => inst._zod.def.innerType;
});
function optional(innerType) {
return new ZodOptional({
type: "optional",
innerType
});
}
const ZodExactOptional = /*@__PURE__*/ $constructor("ZodExactOptional", (inst, def) => {
$ZodExactOptional.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
inst.unwrap = () => inst._zod.def.innerType;
});
function exactOptional(innerType) {
return new ZodExactOptional({
type: "optional",
innerType
});
}
const ZodNullable = /*@__PURE__*/ $constructor("ZodNullable", (inst, def) => {
$ZodNullable.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params);
inst.unwrap = () => inst._zod.def.innerType;
});
function nullable(innerType) {
return new ZodNullable({
type: "nullable",
innerType
});
}
const ZodDefault = /*@__PURE__*/ $constructor("ZodDefault", (inst, def) => {
$ZodDefault.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params);
inst.unwrap = () => inst._zod.def.innerType;
inst.removeDefault = inst.unwrap;
});
function _default(innerType, defaultValue) {
return new ZodDefault({
type: "default",
innerType,
get defaultValue() {
return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
}
});
}
const ZodPrefault = /*@__PURE__*/ $constructor("ZodPrefault", (inst, def) => {
$ZodPrefault.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params);
inst.unwrap = () => inst._zod.def.innerType;
});
function prefault(innerType, defaultValue) {
return new ZodPrefault({
type: "prefault",
innerType,
get defaultValue() {
return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
}
});
}
const ZodNonOptional = /*@__PURE__*/ $constructor("ZodNonOptional", (inst, def) => {
$ZodNonOptional.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);
inst.unwrap = () => inst._zod.def.innerType;
});
function nonoptional(innerType, params) {
return new ZodNonOptional({
type: "nonoptional",
innerType,
...normalizeParams(params)
});
}
const ZodCatch = /*@__PURE__*/ $constructor("ZodCatch", (inst, def) => {
$ZodCatch.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);
inst.unwrap = () => inst._zod.def.innerType;
inst.removeCatch = inst.unwrap;
});
function _catch(innerType, catchValue) {
return new ZodCatch({
type: "catch",
innerType,
catchValue: typeof catchValue === "function" ? catchValue : constantCatch(catchValue)
});
}
const ZodPipe = /*@__PURE__*/ $constructor("ZodPipe", (inst, def) => {
$ZodPipe.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);
inst.in = def.in;
inst.out = def.out;
});
function pipe(in_, out) {
return new ZodPipe({
type: "pipe",
in: in_,
out
});
}
const ZodReadonly = /*@__PURE__*/ $constructor("ZodReadonly", (inst, def) => {
$ZodReadonly.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);
inst.unwrap = () => inst._zod.def.innerType;
});
function readonly(innerType) {
return new ZodReadonly({
type: "readonly",
innerType
});
}
const ZodCustom = /*@__PURE__*/ $constructor("ZodCustom", (inst, def) => {
$ZodCustom.init(inst, def);
ZodType.init(inst, def);
inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params);
});
function custom(fn, _params) {
return /* @__PURE__ */ _custom(ZodCustom, fn ?? (() => true), _params);
}
function refine(fn, _params = {}) {
return /* @__PURE__ */ _refine(ZodCustom, fn, _params);
}
function superRefine(fn, params) {
return /* @__PURE__ */ _superRefine(fn, params);
}
//#endregion
//#region src/utils/zod-parse.ts
/**
* Null-returning Zod parse helpers for plugin and runtime boundaries.
*
* Callers use these where invalid external payloads should be ignored or
* recovered from without constructing and catching validation errors.
*/
/** Safely validates an unknown value with a Zod schema, returning null on validation failure. */
function safeParseWithSchema(schema, value) {
const parsed = schema.safeParse(value);
return parsed.success ? parsed.data : null;
}
/** Parses JSON, then safely validates it with a Zod schema, returning null for parse or schema failures. */
function safeParseJsonWithSchema(schema, raw) {
try {
return safeParseWithSchema(schema, JSON.parse(raw));
} catch {
return null;
}
}
//#endregion
//#region src/infra/gateway-lock-payload.ts
const LockPayloadSchema = object({
pid: number(),
ownerId: string().min(1).optional(),
/** A cold opener may wait for this transient owner, never enter while it is held. */
stateOwnerKind: literal("schema").optional(),
/** Present when Gateway cron writes use the dynamic-default ownership projection. */
cronOwnerProjection: literal("dynamic-default-v1").optional(),
createdAt: string(),
configPath: string(),
port: number().int().min(1).max(65535).optional(),
role: _enum([
"gateway",
"agent-embedded",
"skill-workshop-apply",
"sqlite-maintenance"
]).optional(),
stateDir: string().optional(),
startTime: number().optional()
});
function parseGatewayLockPayload(raw) {
return safeParseJsonWithSchema(LockPayloadSchema, raw);
}
//#endregion
//#region src/infra/private-mode.ts
const CHMOD_UNSUPPORTED_CODES = /* @__PURE__ */ new Set([
"ENOTSUP",
"EOPNOTSUPP",
"EINVAL"
]);
const PRIVATE_PROBE_FILE_MODE = 384;
function hasRestrictivePermissions(target) {
try {
return (statSync(target).mode & 63) === 0;
} catch {
return false;
}
}
function filesystemRejectsChmod(target) {
let probePath;
try {
const probeDir = statSync(target).isDirectory() ? target : path.dirname(target);
probePath = path.join(probeDir, `.openclaw-chmod-probe-${randomUUID()}`);
writeFileSync(probePath, "", {
flag: "wx",
mode: PRIVATE_PROBE_FILE_MODE
});
} catch {
return false;
}
try {
chmodSync(probePath, PRIVATE_PROBE_FILE_MODE);
return false;
} catch (err) {
return err.code === "EPERM";
} finally {
try {
unlinkSync(probePath);
} catch {}
}
}
function canIgnorePrivateChmodError(target, code) {
if (code && CHMOD_UNSUPPORTED_CODES.has(code)) return true;
if (code === "EROFS") return hasRestrictivePermissions(target);
if (code !== "EPERM") return false;
return hasRestrictivePermissions(target) || filesystemRejectsChmod(target);
}
/**
* Applies a private POSIX mode, reporting unsupported filesystems without
* weakening real permission failures.
*/
function applyPrivateModeSync(target, mode) {
try {
chmodSync(target, mode);
return { applied: true };
} catch (err) {
if (!canIgnorePrivateChmodError(target, err.code)) throw err;
return {
applied: false,
error: err
};
}
}
//#endregion
//#region src/infra/gateway-state-owner-directory.ts
function ensureOwnerDirectory(directory, created) {
const firstCreated = fsSync.mkdirSync(directory, {
recursive: true,
mode: 448
});
if (firstCreated && created) {
const boundary = path.toNamespacedPath(firstCreated);
const directories = [];
for (let current = directory;;) {
const { dev, ino } = fsSync.lstatSync(current, { bigint: true });
directories.push({
path: current,
dev,
ino
});
if (path.toNamespacedPath(current) === boundary) break;
const parent = path.dirname(current);
if (parent === current) throw new Error("Created state ownership directory is outside its expected ancestry");
current = parent;
}
for (const entry of directories) {
const previous = created.findIndex((candidate) => candidate.path === entry.path);
if (previous < 0) created.push(entry);
else created[previous] = entry;
}
}
const observed = fsSync.lstatSync(directory);
const uid = process.getuid?.();
if (!observed.isDirectory() || uid !== void 0 && observed.uid !== uid) throw new Error("State ownership directory must be a user-owned real directory");
if (process.platform !== "win32" && (observed.mode & 4095) !== 448) {
applyPrivateModeSync(directory, 448);
if ((fsSync.lstatSync(directory).mode & 63) !== 0) throw new Error("State ownership directory permissions are not private");
}
}
function removeCreatedProjectionDirectories(directories) {
let directory = directories[0];
while (directory) {
try {
const observed = fsSync.lstatSync(directory.path, { bigint: true });
if (observed.isDirectory() && observed.dev === directory.dev && observed.ino === directory.ino) fsSync.rmdirSync(directory.path);
} catch (error) {
const code = extractErrorCode(error);
if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST") throw error;
}
directories.shift();
directory = directories[0];
}
}
//#endregion
//#region src/infra/sqlite-busy-timeout.ts
const lockFailureReportingByDatabase = /* @__PURE__ */ new WeakMap();
function normalizeSqliteNonNegativeInteger(value, label) {
if (!Number.isInteger(value) || value < 0) throw new Error(`${label} must be a non-negative integer`);
return value;
}
function readSqliteBusyTimeout(database) {
const row = database.prepare("PRAGMA busy_timeout").get();
const value = row?.busy_timeout ?? row?.timeout;
return typeof value === "bigint" ? Number(value) : Number(value ?? 0);
}
function setSqliteBusyTimeout(database, busyTimeoutMs) {
const normalizedTimeoutMs = normalizeSqliteNonNegativeInteger(busyTimeoutMs, "busyTimeoutMs");
database.exec(`PRAGMA busy_timeout = ${normalizedTimeoutMs}`);
}
function shouldReportSqliteLockFailure(database) {
return lockFailureReportingByDatabase.get(database) !== "suppress";
}
/** Run with a temporary busy policy; restore early when write admission finishes. */
function runWithSqliteBusyTimeout(database, busyTimeoutMs, operation, options = {}) {
const normalizedTimeoutMs = normalizeSqliteNonNegativeInteger(busyTimeoutMs, "busyTimeoutMs");
const previousBusyTimeoutMs = readSqliteBusyTimeout(database);
const previousLockFailureReporting = lockFailureReportingByDatabase.get(database);
if (options.lockFailureReporting) lockFailureReportingByDatabase.set(database, options.lockFailureReporting);
if (previousBusyTimeoutMs !== normalizedTimeoutMs) setSqliteBusyTimeout(database, normalizedTimeoutMs);
const restore = () => {
if (database.isOpen && previousBusyTimeoutMs !== normalizedTimeoutMs) setSqliteBusyTimeout(database, previousBusyTimeoutMs);
if (previousLockFailureReporting) lockFailureReportingByDatabase.set(database, previousLockFailureReporting);
else lockFailureReportingByDatabase.delete(database);
};
try {
return operation(restore);
} finally {
restore();
}
}
//#endregion
//#region src/infra/stale-lock-file.ts
function readLockFileOwnerPayload(payload) {
if (!payload) return null;
return {
pid: typeof payload.pid === "number" && Number.isInteger(payload.pid) && payload.pid > 0 ? payload.pid : void 0,
createdAt: typeof payload.createdAt === "string" ? payload.createdAt : void 0,
starttime: typeof payload.starttime === "number" && Number.isInteger(payload.starttime) && payload.starttime >= 0 ? payload.starttime : void 0
};
}
/** Capture only the bounded facts used by this exact stale decision. Never
* resample the owner after failure or copy arbitrary sidecar payload fields. */
function inspectStaleLockOwner(params) {
const payload = readLockFileOwnerPayload(params.payload);
if (!payload?.pid) return null;
const observedStarttime = payload.starttime === void 0 ? null : (params.getProcessStartTime ?? getFileLockProcessStartTime)(payload.pid);
const identity = {
pid: payload.pid,
recordedStarttime: payload.starttime ?? null,
observedStarttime
};
const normalizedStored = process.platform === "darwin" && payload.starttime !== void 0 && payload.starttime > 1e10 ? Math.floor(payload.starttime / 1e6) : payload.starttime;
if (observedStarttime !== null && observedStarttime !== normalizedStored) return {
reason: "owner-starttime-changed",
...identity
};
return (params.isPidDefinitelyDead ?? isPidDefinitelyDead)(payload.pid) ? {
reason: "owner-process-exited",
...identity
} : null;
}
function isLockOwnerDefinitelyStale(params) {
return inspectStaleLockOwner(params) !== null;
}
//#endregion
//#region src/infra/gateway-state-owner.ts
function hasPhysicalOwnership(owner) {
return verifyOwnerLock(owner, owner.locks.values().next().value);
}
function verifyOwnerLock(owner, lock) {
owner.verifiedAt = void 0;
if (!lock?.verifyStillHeld()) return false;
owner.verifiedAt = performance.now();
return true;
}
const READ_OWNERSHIP_MAX_AGE_MS = 1e3;
const readOwnerPaths = resolveGlobalSingleton(Symbol.for("openclaw.gatewayStateReadOwnerPaths"), () => /* @__PURE__ */ new Map());
const owners$1 = resolveGlobalSingleton(Symbol.for("openclaw.gatewayStateOwners"), () => /* @__PURE__ */ new Map());
const schemaOwners = resolveGlobalSingleton(Symbol.for("openclaw.stateDatabaseSchemaOwners"), () => new AsyncLocalStorage());
/** The synchronous lexical owner is live authority, not the existence of its sidecar. */
function getStateDatabaseSchemaLease(databasePath) {
const entry = schemaOwners.getStore()?.get(resolveGatewayStateOwnerPath(databasePath));
if (!entry) return;
if (!entry.active) throw new Error("State schema maintenance scope is no longer current");
entry.lease.assertCurrent();
return entry.lease;
}
const GatewayStateOwnerContentionError = resolveGlobalSingleton(Symbol.for("openclaw.gatewayStateOwnerContentionError"), () => class StateOwnerContentionError extends Error {
constructor(databasePath, cause) {
super(`OpenClaw state database is busy at ${databasePath}. Wait for the other OpenClaw process to finish, then retry. If it persists, run \`openclaw gateway status\` and check for other OpenClaw processes using the same state directory. A running Gateway can hold this ownership until it stops; stop it through its service manager or original terminal before retrying.`);
this.databasePath = databasePath;
this.cause = cause;
this.name = "GatewayStateOwnerContentionError";
}
});
const StateDatabaseAdmissionPendingError = resolveGlobalSingleton(Symbol.for("openclaw.stateDatabaseAdmissionPendingError"), () => class extends Error {
constructor(databasePath, message) {
super(message);
this.databasePath = databasePath;
}
});
/** Retry cold admission only; the same budget covers opening and its first unentered write. */
function withStateDatabaseColdAdmission(params, open) {
const budget = normalizeSqliteNonNegativeInteger(params.busyTimeoutMs, "busyTimeoutMs");
const deadline = performance.now() + budget;
const canonical = resolveIdentityPathViaExistingAncestorSync(params.databasePath);
const remainingBusyTimeoutMs = () => Math.max(0, Math.ceil(deadline - performance.now()));
const waiting = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
for (;;) try {
assertStateDatabaseAccessAllowed(params.databasePath);
return open(remainingBusyTimeoutMs);
} catch (error) {
if (!(error instanceof StateDatabaseAdmissionPendingError) || resolveIdentityPathViaExistingAncestorSync(error.databasePath) !== canonical || params.canRetry?.() === false) throw error;
const remaining = deadline - performance.now();
if (remaining <= 0) throw error;
Atomics.wait(waiting, 0, 0, Math.min(10, remaining));
}
}
/** State cleanup preserves this owner until destructive work and native handles settle. */
function resolveGatewayStateOwnerPath(databasePath) {
const canonical = resolveIdentityPathViaExistingAncestorSync(databasePath);
const uid = process.getuid?.();
const directory = process.platform === "win32" ? path.join(os.homedir(), "AppData", "Local", "OpenClaw", "locks", uid === void 0 ? "openclaw-state-owners" : `openclaw-state-owners-${uid}`) : resolveGatewayLockDirForCanonicalStateDir(resolveOpenClawStateDirForDatabasePath(canonical));
return path.join(resolveIdentityPathViaExistingAncestorSync(directory), `state.${sha256HexPrefixCore(canonical, 16)}.lock`);
}
function defaultPayload(databasePath, role = "sqlite-maintenance") {
const stateDir = resolveOpenClawStateDirForDatabasePath(databasePath);
const startTime = getFileLockProcessStartTime(process.pid);
return {
pid: process.pid,
ownerId: randomUUID(),
createdAt: (/* @__PURE__ */ new Date()).toISOString(),
stateDir,
configPath: path.join(stateDir, "openclaw.json"),
role,
...startTime === null ? {} : { startTime }
};
}
function acquireOwnerFile(databasePath, pathname, payload, busyTimeoutMs = 0, createdDirectories) {
const deadline = performance.now() + busyTimeoutMs;
ensureOwnerDirectory(path.dirname(pathname), createdDirectories);
const stale = ({ payload: value }) => {
return isLockOwnerDefinitelyStale({ payload: isRecord(value) ? {
pid: value.pid,
starttime: value.startTime
} : null });
};
if (busyTimeoutMs > 0) try {
const previous = parseGatewayLockPayload(fsSync.readFileSync(pathname, "utf8"));
if (previous && !stale({ payload: previous }) && (previous.pid === process.pid || (previous.role ?? "gateway") === "gateway" && isPidAlive(previous.pid))) throw new GatewayStateOwnerContentionError(databasePath);
} catch (error) {
if (extractErrorCode(error) !== "ENOENT") throw error;
}
for (let retriedMissingParent = false;;) try {
return acquireFileLockSync(pathname, {
lockPath: pathname,
retry: busyTimeoutMs > 0 ? {
factor: 1.25,
minTimeout: 10,
maxTimeout: 25,
randomize: false
} : { retries: 0 },
timeoutMs: Math.max(0, Math.ceil(deadline - performance.now())),
staleMs: Infinity,
staleRecovery: "remove-if-unchanged",
reentrantOwner: payload.ownerId,
payload: () => payload,
parsePayload: parseGatewayLockPayload,
shouldReclaim: stale,
shouldRemoveStaleLock: stale
});
} catch (error) {
const code = extractErrorCode(error);
if (code === "ENOENT" && !retriedMissingParent) {
retriedMissingParent = true;
ensureOwnerDirectory(path.dirname(pathname), createdDirectories);
continue;
}
if (code === "file_lock_timeout" || code === "file_lock_stale") throw new GatewayStateOwnerContentionError(databasePath, error);
throw error;
}
}
function leaseForFile(pathname, lock, owner, projection) {
let released = false;
const lease = {
path: pathname,
assertCurrent() {
if (released || !verifyOwnerLock(owner, lock) || projection && !projection.verifyStillHeld()) throw new Error("OpenClaw state ownership is no longer current");
},
assertDatabaseAccess(databasePath) {
if (released || owners$1.get(pathname) !== owner || resolveGatewayStateOwnerPath(databasePath) !== pathname || !verifyOwnerLock(owner, lock) || projection && !projection.verifyStillHeld()) throw new Error("OpenClaw state maintenance does not own this database");
},
run(operation) {
lease.assertCurrent();
readOwnerPaths.clear();
const inherited = new Map(schemaOwners.getStore());
const entry = {
lease,
active: true
};
inherited.set(pathname, entry);
try {
return schemaOwners.run(inherited, operation);
} finally {
entry.active = false;
readOwnerPaths.clear();
}
},
release() {
readOwnerPaths.clear();
if (!released) {
projection?.release();
lock.release();
released = true;
owner.locks.delete(lock);
if (owner.locks.size === 0 && owners$1.get(pathname) === owner) {
owner.accepting = false;
owners$1.delete(pathname);
}
}
if (owner.locks.size === 0) removeCreatedProjectionDirectories(owner.projectionDirectories);
}
};
return lease;
}
/** Accepted schema work retains the sidecar even when its process owner stops lending. */
function acquireStateDatabaseSchemaLease(databasePath, options = {}) {
readOwnerPaths.clear();
const pathname = resolveGatewayStateOwnerPath(databasePath);
let owner = owners$1.get(pathname);
if (owner && (!owner.accepting || !hasPhysicalOwnership(owner))) throw new GatewayStateOwnerContentionError(databasePath);
if (owner) assertStateDatabaseAccessAllowed(databasePath);
const payload = owner?.payload ?? {
...defaultPayload(databasePath),
stateOwnerKind: "schema"
};
let lock;
const projectionDirectories = [];
try {
lock = acquireOwnerFile(databasePath, pathname, payload, owner ? 0 : options.busyTimeoutMs ?? 5e3, projectionDirectories);
} catch (error) {
if (error instanceof GatewayStateOwnerContentionError) try {
assertStateDatabaseAccessAllowed(databasePath);
} catch (currentOwnerError) {
if (currentOwnerError instanceof StateDatabaseAdmissionPendingError) throw currentOwnerError;
}
throw error;
}
const projectionPath = owner?.projectionPath ?? path.join(resolveGatewayLockDir(resolveOpenClawStateDirForDatabasePath(resolveIdentityPathViaExistingAncestorSync(databasePath))), "gateway.state.lock");
let projection;
try {
projection = owner?.getProjection?.()?.retain() ?? acquireOwnerFile(databasePath, projectionPath, {
...payload,
role: payload.role === "gateway" ? "gateway" : "agent-embedded"
}, 0, projectionDirectories);
} catch (error) {
return runWithSqliteCleanup({ release() {
lock.release();
removeCreatedProjectionDirectories(projectionDirectories);
} }, "state schema projection admission", () => {
throw error;
});
}
if (owner) {
owner.locks.add(lock);
owner.projectionDirectories.push(...projectionDirectories);
} else {
owner = {
kind: "schema",
payload,
projectionPath,
locks: /* @__PURE__ */ new Set([lock]),
projectionDirectories,
accepting: true
};
owners$1.set(pathname, owner);
}
const lease = leaseForFile(pathname, lock, owner, projection);
try {
lease.assertCurrent();
return lease;
} catch (error) {
return runWithSqliteCleanup(lease, "state schema ownership verification", () => {
throw error;
});
}
}
function hasRecentVerification(verifiedAt, now) {
return verifiedAt !== void 0 && now - verifiedAt < READ_OWNERSHIP_MAX_AGE_MS;
}
/** Only explicit reads reuse recent physical verification; mutations always check freshly. */
function assertStateDatabaseReadAllowed(databasePath) {
if (owners$1.size === 0) {
assertStateDatabaseAccessAllowed(databasePath);
return;
}
const key = path.resolve(databasePath);
const now = performance.now();
const cached = readOwnerPaths.get(key);
const projection = cached?.owner.getProjection?.();
if (cached && now < cached.expiresAt && owners$1.get(cached.pathname) === cached.owner && cached.owner.accepting && hasRecentVerification(cached.owner.verifiedAt, now) && (!cached.owner.getProjection || projection && hasRecentVerification(projection.verifiedAt, now))) return;
readOwnerPaths.delete(key);
const pathname = resolveGatewayStateOwnerPath(databasePath);
const owner = owners$1.get(pathname);
const role = owner?.payload.role ?? "gateway";
if (!owner || owner.kind !== "process" || !owner.accepting || role !== "gateway" && role !== "agent-embedded") {
assertStateDatabaseAccessAllowed(databasePath);
return;
}
if (!hasPhysicalOwnership(owner) || owner.getProjection && !owner.getProjection()?.verifyStillHeld()) throw new Error(`OpenClaw state ownership at ${databasePath} could not be verified; retry after maintenance finishes.`);
readOwnerPaths.set(key, {
pathname,
owner,
expiresAt: now + READ_OWNERSHIP_MAX_AGE_MS
});
}
/** Ordinary SQLite access observes maintenance; it never borrows schema authority. */
function assertStateDatabaseAccessAllowed(databasePath, captured) {
const assertMaintenance = () => {
const schemaLease = captured ? captured.schemaLease : getStateDatabaseSchemaLease(databasePath);
if (schemaLease) {
schemaLease.assertDatabaseAccess(databasePath);
return;
}
const scope = captured ? captured.maintenanceScope : getOpenClawDatabaseMaintenanceScope();
if (!scope) throw new Error(`OpenClaw state at ${databasePath} is undergoing offline maintenance; retry when it finishes.`);
scope.assertDatabaseAccess(databasePath);
};
const pathname = resolveGatewayStateOwnerPath(databasePath);
const local = owners$1.get(pathname);
const unavailable = `OpenClaw state ownership at ${databasePath} could not be verified; retry after maintenance finishes.`;
if (local) {
if (!hasPhysicalOwnership(local)) throw new Error(unavailable);
const role = local.payload.role ?? "gateway";
if (!local.accepting || role !== "gateway" && role !== "agent-embedded") assertMaintenance();
return;
}
let raw;
try {
raw = fsSync.readFileSync(pathname, "utf8");
} catch (error) {
if (extractErrorCode(error) === "ENOENT") return;
throw new Error(unavailable, { cause: error });
}
const owner = parseGatewayLockPayload(raw);
if (!owner) throw new StateDatabaseAdmissionPendingError(databasePath, unavailable);
if (!Number.isSafeInteger(owner.pid) || owner.pid <= 0) throw new Error(unavailable);
if (isLockOwnerDefinitelyStale({ payload: {
pid: owner.pid,
starttime: owner.startTime
} })) return;
if (owner.pid === process.pid && !isMainThread) return;
if (!isPidAlive(owner.pid)) throw new Error(unavailable);
const role = owner.role ?? "gateway";
if (role === "gateway" || role === "agent-embedded") return;
if (owner.pid === process.pid) {
assertMaintenance();
return;
}
if (owner.stateOwnerKind === "schema" && owner.role === "sqlite-maintenance") throw new StateDatabaseAdmissionPendingError(databasePath, `OpenClaw state at ${databasePath} is undergoing offline maintenance; retry when it finishes.`);
throw new Error(`OpenClaw state at ${databasePath} is undergoing offline maintenance; retry when it finishes.`);
}
//#endregion
//#region node-version.mjs
const NODE_RELEASE_VERSION_RE = /^v?((?:0|[1-9]\d*))\.((?:0|[1-9]\d*))\.((?:0|[1-9]\d*))(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u;
const NODE_RELEASE_FLOORS = [{
major: 24,
minor: 16,
patch: 0
}, {
major: 26,
minor: 1,
patch: 0
}];
NODE_RELEASE_FLOORS[NODE_RELEASE_FLOORS.length - 1];
`${NODE_RELEASE_FLOORS.map(({ major, minor, patch }, index) => `>=${major}.${minor}.${patch}${index < NODE_RELEASE_FLOORS.length - 1 ? ` <${major + 1}` : ""}`).join(" || ").replaceAll(" || ", ", ").replace(/, ([^,]+)$/, ", or $1")}`;
/** Parses an anchored release SemVer, allowing a leading v and valid build metadata. */
function parseNodeReleaseVersion(value) {
if (typeof value !== "string") return null;
const match = NODE_RELEASE_VERSION_RE.exec(value.trim());
if (!match) return null;
const version = {
major: Number(match[1]),
minor: Number(match[2]),
patch: Number(match[3])
};
return Object.values(version).every(Number.isSafeInteger) ? version : null;
}
function isNodeVersionAtLeast(version, minimum) {
if (!version) return false;
if (version.major !== minimum.major) return version.major > minimum.major;
if (version.minor !== minimum.minor) return version.minor > minimum.minor;
return version.patch >= minimum.patch;
}
function renderProcessNodeVersionCheck() {
return `((value) => {
if (typeof value !== "string") return false;
const match = new RegExp(${JSON.stringify(NODE_RELEASE_VERSION_RE.source)}, "u").exec(value.trim());
if (!match) return false;
const version = { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) };
if (!Object.values(version).every(Number.isSafeInteger)) return false;
const floors = ${JSON.stringify(NODE_RELEASE_FLOORS)};
const minimum = floors.find((floor) => floor.major === version.major);
const atLeast = (floor) =>
version.major > floor.major ||
(version.major === floor.major &&
(version.minor > floor.minor ||
(version.minor === floor.minor && version.patch >= floor.patch)));
return minimum ? atLeast(minimum) : version.major > floors[floors.length - 1].major;
})(process.versions.node)`;
}
renderProcessNodeVersionCheck();
//#endregion
//#region node-sqlite.mjs
function probeSqlite(DatabaseSync) {
const result = {
available: false,
version: null,
text: false,
blob: false,
json: false
};
let database;
try {
database = new DatabaseSync(":memory:");
result.available = true;
const version = database.prepare("SELECT sqlite_version() AS version").get()?.version;
result.version = typeof version === "string" ? version : null;
const text = "a\0b\0";
const bytes = Buffer.from(text, "utf8");
const json = JSON.stringify({ value: text });
database.exec("CREATE TABLE probe (text_value TEXT, blob_value BLOB, json_value TEXT)");
database.prepare("INSERT INTO probe VALUES (?, ?, ?)").run(text, bytes, json);
const row = database.prepare("SELECT text_value, blob_value, json_value FROM probe").get();
result.text = typeof row?.text_value === "string" && row.text_value.length === 4 && Buffer.from(row.text_value, "utf8").equals(bytes);
result.blob = row?.blob_value instanceof Uint8Array && Buffer.from(row.blob_value).equals(bytes);
result.json = row?.json_value === json && JSON.parse(row.json_value).value === text;
} catch (error) {
result.error = error instanceof Error ? error.message : String(error);
} finally {
database?.close();
}
return result;
}
function isSqliteWalResetSafeVersion(value) {
const match = /^(\d+)\.(\d+)\.(\d+)$/u.exec(value.trim());
if (!match) return false;
const [major, minor, patch] = match.slice(1).map(Number);
if (![
major,
minor,
patch
].every(Number.isSafeInteger)) return false;
return major > 3 || major === 3 && (minor > 51 || minor === 51 && patch >= 3 || minor === 50 && patch >= 7 || minor === 44 && patch >= 6);
}
`${probeSqlite.toString()}`;
//#endregion
//#region src/infra/bun-sqlite-library.ts
const WORKER_SELECTION_KEY = "openclaw.bunSqliteLibrarySelection";
function probeLibrary(path) {
const { dlopen, FFIType } = createRequire(import.meta.url)("bun:ffi");
const library = dlopen(path, {
sqlite3_libversion: {
args: [],
returns: FFIType.cstring
},
sqlite3_compileoption_used: {
args: [FFIType.cstring],
returns: FFIType.i32
}
});
try {
return {
version: String(library.symbols.sqlite3_libversion()),
extensionLoadingSupported: library.symbols.sqlite3_compileoption_used(Buffer.from("OMIT_LOAD_EXTENSION\0")) === 0
};
} finally {
library.close();
}
}
function selectLibrary(path) {
const { Database } = createRequire(import.meta.url)("bun:sqlite");
Database.setCustomSQLite(path);
}
function createSelector(deps) {
let selection;
let failure;
return (options = {}) => {
if (failure) throw failure;
if (selection) return selection;
const override = options.explicitPath ?? (deps.env.OPENCLAW_SQLITE_LIBRARY?.trim() || void 0);
if (!deps.isBun || deps.platform !== "darwin") {
selection = override ? {
source: "runtime",
ignoredOverride: "OPENCLAW_SQLITE_LIBRARY requires Bun on macOS"
} : { source: "runtime" };
return selection;
}
const prefix = deps.env.HOMEBREW_PREFIX?.trim();
const candidates = override !== void 0 ? [override] : [.../* @__PURE__ */ new Set([
...prefix ? [posix.join(prefix, "opt/sqlite/lib/libsqlite3.dylib")] : [],
"/opt/homebrew/opt/sqlite/lib/libsqlite3.dylib",
"/usr/local/opt/sqlite/lib/libsqlite3.dylib",
"/opt/local/lib/libsqlite3.dylib"
])];
for (const path of candidates) {
let probe;
try {
try {
probe = deps.probe(path);
} catch (error) {
throw deps.exists(path) ? error : new Error("missing file", { cause: error });
}
if (!isSqliteWalResetSafeVersion(probe.version)) throw new Error(`SQLite version ${probe.version} below the WAL safety floor`);
if (!probe.extensionLoadingSupported) throw new Error("built with SQLITE_OMIT_LOAD_EXTENSION");
} catch (error) {
if (override === void 0) continue;
failure = selectionError(path, error);
throw failure;
}
try {
deps.select(path);
} catch (error) {
failure = selectionError(path, error);
throw failure;
}
selection = {
source: override === void 0 ? "discovered" : "env",
path,
version: probe.version,
extensionLoadingSupported: true
};
return selection;
}
selection = { source: "runtime" };
return selection;
};
}
function selectionError(path, error) {
return new Error(`Cannot use SQLite library ${path}: ${error instanceof Error ? error.message : String(error)}. Fix or unset OPENCLAW_SQLITE_LIBRARY; install a supported library with brew install sqlite.`, { cause: error });
}
function inheritedSelection() {
const value = getEnvironmentData(WORKER_SELECTION_KEY);
if (value === void 0) return;
if (value !== null && typeof value === "object" && !Array.isArray(value)) {
const source = "source" in value ? value.source : void 0;
if (source === "runtime") return { source: "runtime" };
const path = "path" in value ? value.path : void 0;
const version = "version" in value ? value.version : void 0;
const extensionLoadingSupported = "extensionLoadingSupported" in value ? value.extensionLoadingSupported : void 0;
if ((source === "env" || source === "discovered") && typeof path === "string" && typeof version === "string" && extensionLoadingSupported === true) return {
source,
path,
version,
extensionLoadingSupported: true
};
}
throw new Error("Invalid inherited SQLite library selection");
}
function createRuntimeSelector() {
const isBun = Boolean(process.versions.bun);
const sharedLibrary = isBun && process.platform === "darwin";
const inherited = sharedLibrary && !isMainThread ? inheritedSelection() : void 0;
if (inherited) return () => inherited;
const select = createSelector({
isBun,
platform: process.platform,
env: process.env,
exists: existsSync,
probe: probeLibrary,
select: selectLibrary
});
let published = false;
return (options) => {
const selection = select(options);
if (sharedLibrary && isMainThread && !published) {
setEnvironmentData(WORKER_SELECTION_KEY, Object.freeze({ ...selection }));
published = true;
}
return selection;
};
}
/** Select once, before any SQLite open; shared across CLI and bundled SDK module graphs. */
function ensureSqliteLibrarySelected(options) {
const dependencies = options?.internals;
return (dependencies ? dependencies.selector ??= createSelector(dependencies) : resolveGlobalSingleton(Symbol.for("openclaw.bunSqliteLibrarySelection"), createRuntimeSelector))(options);
}
//#endregion
//#region src/infra/sqlite-reader-lifecycle.ts
const readerOwners = resolveGlobalSingleton(Symbol.for("openclaw.sqliteReaderOwners"), () => new AsyncLocalStorage());
const activeReaders = resolveGlobalSingleton(Symbol.for("openclaw.sqliteActiveReaders"), () => ({
byDatabase: /* @__PURE__ */ new WeakMap(),
byPath: /* @__PURE__ */ new Map()
}));
const connections = resolveGlobalSingleton(Symbol.for("openclaw.sqliteReaderConnections"), () => ({
nextId: 0,
byDatabase: /* @__PURE__ */ new WeakMap(),
byPath: /* @__PURE__ */ new Map(),
finalizer: new FinalizationRegistry((connection) => forgetConnection(connection))
}));
/** The same Windows file can arrive with a namespaced or differently cased path. */
function sqliteReaderDatabasePathKey(databasePath) {
const resolved = path.resolve(databasePath);
return process.platform === "win32" ? normalizeWindowsPathForComparison(resolved) : resolved;
}
function boundedOperation(operation) {
return (operation.trim() || "sqlite reader").slice(0, 120);
}
function captureSqliteReaderOwner() {
const owner = readerOwners.getStore();
return owner ? { ...owner } : void 0;
}
function currentOwner(fallbackOperation, capturedOwner) {
const inherited = capturedOwner ?? readerOwners.getStore();
return {
operation: boundedOperation(inherited?.operation ?? fallbackOperation),
ownerKind: inherited?.ownerKind ?? (isMainThread ? "main" : "worker"),
...inherited?.actorId !== void 0 ? { actorId: inherited.actorId } : {}
};
}
function connectionFor(database) {
let connection = connections.byDatabase.get(database);
if (!connection) {
const now = Date.now();
const location = database.location();
connection = {
id: ++connections.nextId,
path: location ? sqliteReaderDatabasePathKey(location) : void 0,
database: new WeakRef(database),
owner: currentOwner("sqlite connection"),
openedAtMs: now
};
connections.byDatabase.set(database, connection);
if (connection.path) {
const entries = connections.byPath.get(connection.path) ?? /* @__PURE__ */ new Map();
entries.set(connection.id, connection);
connections.byPath.set(connection.path, entries);
}
connections.finalizer.register(database, connection, connection);
}
return connection;
}
/** Forget observations only; explicit reader custody belongs to its caller. */
function forgetConnection(connection) {
if (connection.path) {
const entries = connections.byPath.get(connection.path);
entries?.delete(connection.id);
if (entries?.size === 0) connections.byPath.delete(connection.path);
}
const database = connection.database.deref();
if (database && connections.byDatabase.get(database) === connection) connections.byDatabase.delete(database);
connections.finalizer.unregister(connection);
}
/** Register weak metadata without replacing native methods or acquiring lifecycle custody. */
function registerSqliteReaderConnection(database) {
if (database.isOpen) connectionFor(database);
}
function retainSqliteReader(database, fallbackOperation, capturedOwner) {
const connection = connectionFor(database);
const now = Date.now();
const reader = {
...currentOwner(fallbackOperation, capturedOwner),
kind: "iterator",
connectionId: connection.id,
threadId,
startedAtMs: now,
lastProgressAtMs: now
};
const token = Symbol(reader.operation);
const databaseReaders = activeReaders.byDatabase.get(database) ?? /* @__PURE__ */ new Map();
databaseReaders.set(token, reader);
activeReaders.byDatabase.set(database, databaseReaders);
const databasePath = connection.path;
const pathReaders = databasePath ? activeReaders.byPath.get(databasePath) ?? /* @__PURE__ */ new Map() : void 0;
pathReaders?.set(token, reader);
if (databasePath && pathReaders) activeReaders.byPath.set(databasePath, pathReaders);
let released = false;
return {
progress() {
if (!released) reader.lastProgressAtMs = Date.now();
},
release() {
if (released) return;
released = true;
databaseReaders.delete(token);
if (databaseReaders.size === 0 && activeReaders.byDatabase.get(database) === databaseReaders) activeReaders.byDatabase.delete(database);
pathReaders?.delete(token);
if (databasePath && pathReaders?.size === 0 && activeReaders.byPath.get(databasePath) === pathReaders) activeReaders.byPath.delete(databasePath);
}
};
}
function diagnostics(readers) {
const now = Date.now();
return [...readers].map(({ startedAtMs, lastProgressAtMs, ...reader }) => Object.assign(reader, {
ageMs: Math.max(0, now - startedAtMs),
idleMs: Math.max(0, now - lastProgressAtMs)
})).toSorted((left, right) => right.ageMs - left.ageMs).slice(0, 8);
}
/** Observed local activity is diagnostic evidence, not proof of which connection owns a WAL lock. */
function readSqliteReaderDiagnosticsForPath(databasePath) {
const key = sqliteReaderDatabasePathKey(databasePath);
const entries = connections.byPath.get(key);
const localConnections = [];
const now = Date.now();
for (const connection of entries?.values() ?? []) {
const database = connection.database.deref();
if (!database?.isOpen) {
forgetConnection(connection);
continue;
}
const location = database.location();
if (!location || sqliteReaderDatabasePathKey(location) !== key) {
forgetConnection(connection);
continue;
}
const readers = activeReaders.byDatabase.get(database);
localConnections.push({
...connection.owner,
connectionId: connection.id,
threadId,
ageMs: Math.max(0, now - connection.openedAtMs),
transactionOpen: database.isTransaction,
trackedReaders: readers?.size ?? 0
});
}
const readers = activeReaders.byPath.get(key);
return {
scope: "current-thread",
blockingOwner: "unknown",
nativeStatements: "unobserved",
threadId,
observedAtMs: now,
connectionCount: localConnections.length,
readerCount: readers?.size ?? 0,
connections: localConnections.toSorted((left, right) => right.trackedReaders - left.trackedReaders || Number(right.transactionOpen) - Number(left.transactionOpen)).slice(0, 8),
activeReaders: diagnostics(readers?.values() ?? [])
};
}
//#endregion
//#region src/infra/sqlite-pinned-read-snapshot.ts
const snapshots = resolveGlobalSingleton(Symbol.for("openclaw.sqlitePinnedReadSnapshots"), () => /* @__PURE__ */ new WeakMap());
function getSqlitePinnedReadSnapshot(db) {
return snapshots.get(db);
}
/** Pin an implicit read snapshot without requiring transaction-control authorization. */
function runSqlitePinnedReadSnapshotSync(db, operation) {
const parent = snapshots.get(db);
snapshots.set(db, parent ?? {});
try {
return executeWithCachedStatement(db, "PRAGMA schema_version", [], (statement) => {
const snapshot = statement.iterate();
try {
const first = snapshot.next();
if (first.done) throw new Error("SQLite schema version query returned no row");
return operation(Number(first.value.schema_version));
} finally {
snapshot.return?.();
}
});
} finally {
if (!parent) snapshots.delete(db);
}
}
//#endregion
//#region src/infra/sqlite-schema-sql.ts
const TABLE_CONSTRAINT_KEYWORDS = /* @__PURE__ */ new Set([
"CHECK",
"FOREIGN",
"PRIMARY",
"UNIQUE"
]);
/** Select canonical DDL without opening a database or changing its installation lifecycle. */
function extractSqliteTableSchema(schema, table, options = {}) {
const start = schema.indexOf(`CREATE TABLE IF NOT EXISTS ${table} (`);
const endMarker = options.endMarker ?? "\n) STRICT;";
const end = schema.indexOf(endMarker, start);
if (start < 0 || end < start) throw new Error(options.errorMessage ?? `Canonical schema markers are missing for ${table}`);
return schema.slice(start, end + (options.includeEndMarker === false ? 0 : endMarker.length));
}
function readTableConstraintKeyword(sql, first) {
let token = first;
if (token.keyword === "CONSTRAINT") {
const name = readSqlToken(sql, token.end);
token = name ? readSqlToken(sql, name.end) : null;
}
return token?.keyword && TABLE_CONSTRAINT_KEYWORDS.has(token.keyword) ? token.keyword : null;
}
function readSqlToken(sql, start) {
let index = start;
while (index < sql.length && /\s/u.test(sql[index] ?? "")) index += 1;
const char = sql[index];
if (!char) return null;
if (char === "\"" || char === "`" || char === "[") {
const end = skipSqlQuoted(sql, index, char);
return {
end,
keyword: null,
raw: sql.slice(index, end)
};
}
let end = index;
while (end < sql.length && !/[\s(,]/u.test(sql[end] ?? "")) end += 1;
const raw = sql.slice(index, end);
return {
end,
keyword: raw.toUpperCase(),
raw
};
}
function normalizeSqlIdentifier(identifier) {
if (identifier.startsWith("\"") && identifier.endsWith("\"")) return identifier.slice(1, -1).replaceAll("\"\"", "\"").toLowerCase();
if (identifier.startsWith("`") && identifier.endsWith("`")) return identifier.slice(1, -1).replaceAll("``", "`").toLowerCase();
if (identifier.startsWith("[") && identifier.endsWith("]")) return identifier.slice(1, -1).toLowerCase();
return identifier.toLowerCase();
}
function normalizeSchemaSql(sql) {
if (sql === null) return null;
return normalizeSqlWhitespace(sql).replace(/;\s*$/u, "").trim().replace(/^(CREATE (?:TABLE|VIRTUAL TABLE|UNIQUE INDEX|INDEX|TRIGGER)) IF NOT EXISTS /iu, "$1 ");
}
function splitSqlList(sql) {
const items = [];
let depth = 0;
let start = 0;
let index = 0;
while (index < sql.length) {
const next = skipSqlQuotedOrComment(sql, index);
if (next !== index) {
index = next;
continue;
}
const char = sql[index];
if (char === "(") depth += 1;
else if (char === ")") depth -= 1;
else if (char === "," && depth === 0) {
items.push(sql.slice(start, index));
start = index + 1;
}
index += 1;
}
items.push(sql.slice(start));
return items;
}
function findSqlCharacter(sql, character) {
let index = 0;
while (index < sql.length) {
const next = skipSqlQuotedOrComment(sql, index);
if (next !== index) {
index = next;
continue;
}
if (sql[index] === character) return index;
index += 1;
}
return -1;
}
function findSqlClosingParenthesis(sql, open) {
let depth = 0;
let index = open;
while (index < sql.length) {
const next = skipSqlQuotedOrComment(sql, index);
if (next !== index) {
index = next;
continue;
}
const char = sql[index];
if (char === "(") depth += 1;
else if (char === ")") {
depth -= 1;
if (depth === 0) return index;
}
index += 1;
}
throw new Error("SQLite schema contains an unterminated table definition.");
}
function normalizeSqlWhitespace(sql) {
let normalized = "";
let pendingSpace = false;
const segments = /[^\s'"`[/-]+|\s+|./gsu;
let segment;
while (segment = segments.exec(sql)) {
const index = segment.index;
const char = segment[0][0] ?? "";
const quoted = skipSqlQuoted(sql, index, char);
if (quoted !== index) {
if (pendingSpace && normalized.length > 0) normalized += " ";
normalized += sql.slice(index, quoted);
pendingSpace = false;
segments.lastIndex = quoted;
continue;
}
const comment = skipSqlComment(sql, index);
if (comment !== index) {
pendingSpace = true;
segments.lastIndex = comment;
continue;
}
if (/\s/u.test(char)) pendingSpace = true;
else {
if (pendingSpace && normalized.length > 0) normalized += " ";
normalized += segment[0];
pendingSpace = false;
}
}
return normalized.trim();
}
function quoteSqliteIdentifier(identifier) {
return `"${identifier.replaceAll("\"", "\"\"")}"`;
}
function skipSqlQuotedOrComment(sql, index) {
const quoted = skipSqlQuoted(sql, index, sql[index] ?? "");
return quoted !== index ? quoted : skipSqlComment(sql, index);
}
function skipSqlQuoted(sql, index, quote) {
if (quote !== "'" && quote !== "\"" && quote !== "`" && quote !== "[") return index;
const closingQuote = quote === "[" ? "]" : quote;
let cursor = index + 1;
while (cursor < sql.length) {
if (sql[cursor] !== closingQuote) {
cursor += 1;
continue;
}
if (quote !== "[" && sql[cursor + 1] === closingQuote) {
cursor += 2;
continue;
}
return cursor + 1;
}
return sql.length;
}
function skipSqlComment(sql, index) {
if (sql.startsWith("--", index)) {
const newline = sql.indexOf("\n", index + 2);
return newline === -1 ? sql.length : newline + 1;
}
if (sql.startsWith("/*", index)) {
const close = sql.indexOf("*/", index + 2);
return close === -1 ? sql.length : close + 2;
}
return index;
}
//#endregion
//#region src/infra/sqlite-schema-facts.ts
const scopes = resolveGlobalSingleton(Symbol.for("openclaw.sqliteSchemaScopes"), () => {
const byIdentity = /* @__PURE__ */ new Map();
const release = (scope) => {
scope.users -= 1;
if (scope.users === 0 && scope.key && byIdentity.get(scope.key) === scope) byIdentity.delete(scope.key);
};
return {
byIdentity,
release,
finalizer: new FinalizationRegistry(release)
};
});
const owners = resolveGlobalSingleton(Symbol.for("openclaw.sqliteSchemaFacts"), () => /* @__PURE__ */ new WeakMap());
function invalidate(owner) {
owner.revision += 1;
owner.facts = void 0;
}
function bindScope(database, owner) {
if (owner.scope) return owner.scope;
const location = database.location();
const key = location ? readDatabasePathIdentitySync(location).key : void 0;
const scope = key && scopes.byIdentity.get(key) || {
key,
revision: 0,
users: 0
};
if (key) scopes.byIdentity.set(key, scope);
scope.users += 1;
owner.scope = scope;
owner.scopeRevision = scope.revision;
scopes.finalizer.register(database, scope, owner);
return scope;
}
function publishSchemaChange(database, owner) {
const scope = bindScope(database, owner);
scope.revision += 1;
owner.scopeRevision = scope.revision;
}
/** Schema publications outside DDL (such as a deferred version marker) share this revision. */
function invalidateSqliteSchemaFacts(database) {
const owner = owners.get(database);
if (owner) {
bindScope(database, owner);
invalidate(owner);
owner.transactionalSchema ||= database.isTransaction;
if (!database.isTransaction) publishSchemaChange(database, owner);
}
}
function changesSchema(sql) {
return /\b(?:CREATE|ALTER|DROP|REINDEX|VACUUM)\b|\bPRAGMA\b[\s\S]*\b(?:user_version|schema_version|writable_schema)\b[\s\S]*[=(]/i.test(sql);
}
const transactionControlPrefix = /^(?:\s|;|--[^\n]*(?:\n|$)|\/\*(?:[^*]|\*(?!\/))*\*\/)*(BEGIN|SAVEPOINT|COMMIT|END|RELEASE|ROLLBACK)\b/i;
function batchTransactionControl(sql) {
let control;
let remaining = sql;
while (remaining) {
const next = transactionControlPrefix.exec(remaining)?.[1]?.toUpperCase();
if (next === "ROLLBACK") return next;
control ||= next;
const end = remaining.includes(";") ? findSqlCharacter(remaining, ";") : -1;
if (end < 0) break;
remaining = remaining.slice(end + 1);
}
return control;
}
function callStatement(method, [first, ...remaining]) {
if (first === void 0) return method();
if (typeof first === "object" && first !== null && !ArrayBuffer.isView(first)) return method(first, ...remaining);
return method(first, ...remaining);
}
function trackSchemaChanges(database, owner, native) {
const settle = (boundary = false) => {
if ((boundary || !database.isTransaction) && (owner.transactionalSchema || owner.transactionalFacts)) {
if (owner.transactionalSchema) publishSchemaChange(database, owner);
invalidate(owner);
owner.transactionalSchema &&= database.isTransaction;
owner.transactionalFacts = false;
}
};
const execute = (operation, schemaChange, control) => {
if (owner.transactionalSchema && !owner.scope) bindScope(database, owner);
settle();
const invalidates = schemaChange || control === "ROLLBACK" && owner.transactionalSchema;
if (invalidates) invalidateSqliteSchemaFacts(database);
try {
return operation();
} finally {
if (invalidates) invalidateSqliteSchemaFacts(database);
settle(Boolean(control));
}
};
database.exec = (sql) => execute(() => native.DatabaseSync.prototype.exec.call(database, sql), changesSchema(sql), batchTransactionControl(sql));
database.prepare = (...prepareArgs) => {
const [sql] = prepareArgs;
const statement = native.DatabaseSync.prototype.prepare.call(database, ...prepareArgs);
const schemaChange = changesSchema(sql);
const control = transactionControlPrefix.exec(sql)?.[1]?.toUpperCase();
if (schemaChange || control) {
const run = Object.hasOwn(statement, "run") ? statement.run.bind(statement) : void 0;
const get = Object.hasOwn(statement, "get") ? statement.get.bind(statement) : void 0;
const all = Object.hasOwn(statement, "all") ? statement.all.bind(statement) : void 0;
const iterate = Object.hasOwn(statement, "iterate") ? statement.iterate.bind(statement) : void 0;
statement.run = (...bindings) => execute(() => callStatement(run ?? native.StatementSync.prototype.run.bind(statement), bindings), schemaChange, control);
statement.get = (...bindings) => execute(() => callStatement(get ?? native.StatementSync.prototype.get.bind(statement), bindings), schemaChange, control);
statement.all = (...bindings) => execute(() => callStatement(all ?? native.StatementSync.prototype.all.bind(statement), bindings), schemaChange, control);
statement.iterate = function* (...bindings) {
if (owner.transactionalSchema && !owner.scope) bindScope(database, owner);
settle();
const invalidates = schemaChange || control === "ROLLBACK" && owner.transactionalSchema;
if (invalidates) invalidateSqliteSchemaFacts(database);
try {
yield* callStatement(iterate ?? native.StatementSync.prototype.iterate.bind(statement), bindings);
} finally {
if (invalidates) invalidateSqliteSchemaFacts(database);
settle(Boolean(control));
}
};
}
return statement;
};
if (typeof database.setAuthorizer === "function") database.setAuthorizer = (callback) => {
native.DatabaseSync.prototype.setAuthorizer.call(database, callback);
owner.authorizerActive = callback !== null;
invalidate(owner);
};
registerNodeSqliteDisposeCallback(database, () => {
invalidate(owner);
owner.dataVersion = void 0;
owner.readDataVersion = void 0;
if (owner.scope) {
scopes.finalizer.unregister(owner);
scopes.release(owner.scope);
owner.scope = void 0;
owner.scopeRevision = void 0;
}
});
}
/** Share freshness only within this synchronous call stack, never across an await. */
function runSqliteReadOperationSync(database, operation) {
const owner = owners.get(database);
if (!owner?.admitted || owner.authorizerActive) return operation();
owner.readDepth += 1;
try {
return operation();
} finally {
owner.readDepth -= 1;
if (owner.readDepth === 0) owner.readDataVersion = void 0;
}
}
/** Foreign commits are observed on the next operation; SQLite owns snapshot visibility. */
function readSqliteCacheDataVersion(database) {
const tracked = owners.get(database);
const owner = tracked?.admitted ? tracked : void 0;
if (owner && !owner.authorizerActive && owner.readDataVersion !== void 0) return owner.readDataVersion;
const row = executeWithCachedStatement(database, "PRAGMA data_version", [], (statement) => statement.get());
if (typeof row?.data_version !== "number") throw new Error("SQLite did not return a numeric PRAGMA data_version");
if (owner) {
if (owner.dataVersion !== row.data_version) {
const facts = owner.facts;
if (!(facts && runSqlitePinnedReadSnapshotSync(database, (schemaVersion) => {
const userVersion = executeWithCachedStatement(database, "PRAGMA user_version", [], (s) => s.get());
return facts.schemaVersion === schemaVersion && facts.userVersion === userVersion?.user_version;
}))) invalidate(owner);
owner.dataVersion = row.data_version;
}
if (owner.readDepth > 0 && !owner.authorizerActive) owner.readDataVersion = row.data_version;
}
return row.data_version;
}
/** Install at native open, before callers can retain statements or install an authorizer. */
function trackSqliteSchema(database, native) {
if (!owners.has(database)) {
const owner = {
admitted: false,
revision: 0,
readDepth: 0,
transactionalSchema: false,
transactionalFacts: false,
authorizerActive: false
};
owners.set(database, owner);
trackSchemaChanges(database, owner, native);
}
}
/** Only database admission opts a connection into retained schema facts. */
function admitSqliteSchema(database) {
const owner = owners.get(database);
if (!owner) throw new Error("SQLite schema admission requires a connection tracked from native open");
owner.admitted = true;
getAdmittedSqliteSchemaFacts(database);
}
/** Schema changes revoke the admission; ordinary reads consume its recorded facts. */
function getAdmittedSqliteSchemaFacts(database) {
const owner = owners.get(database);
if (!owner?.admitted || owner.authorizerActive) return;
readSqliteCacheDataVersion(database);
const snapshot = getSqlitePinnedReadSnapshot(database);
if (owner.snapshot && owner.snapshot !== snapshot) {
invalidate(owner);
owner.snapshot = void 0;
}
const scope = bindScope(database, owner);
if (owner.scopeRevision !== scope.revision) {
invalidate(owner);
owner.scopeRevision = scope.revision;
}
if ((owner.transactionalSchema || owner.transactionalFacts) && !database.isTransaction) {
if (owner.transactionalSchema) publishSchemaChange(database, owner);
invalidate(owner);
owner.transactionalSchema = false;
owner.transactionalFacts = false;
}
if (!owner.facts) {
owner.snapshot = snapshot;
owner.transactionalFacts = database.isTransaction;
owner.facts = runSqlitePinnedReadSnapshotSync(database, (schemaVersion) => {
const userVersion = executeWithCachedStatement(database, "PRAGMA user_version", [], (s) => s.get());
const tables = executeWithCachedStatement(database, "SELECT name, sql FROM main.sqlite_schema WHERE type = 'table'", [], (s) => s.all());
return {
revision: owner.revision,
userVersion: Number(userVersion?.user_version ?? 0),
schemaVersion,
tables: new Set(tables.flatMap((row) => typeof row.name === "string" ? [row.name] : [])),
tableSql: new Map(tables.flatMap((row) => typeof row.name === "string" ? [[row.name, typeof row.sql === "string" ? row.sql : null]] : []))
};
});
}
return owner.facts;
}
//#endregion
//#region src/infra/warning-filter.ts
const warningFilterKey = Symbol.for("openclaw.warning-filter");
function shouldIgnoreWarning(warning) {
return Boolean(warning.code === "DEP0040" && warning.message?.includes("punycode") || warning.code === "DEP0060" && warning.message?.includes("util._extend") || warning.name === "ExperimentalWarning" && warning.message?.includes("SQLite is an experimental feature"));
}
function normalizeWarningArgs(args) {
const warningArg = args[0];
const secondArg = args[1];
const thirdArg = args[2];
let name;
let code;
let message;
if (warningArg instanceof Error) {
name = warningArg.name;
message = warningArg.message;
code = warningArg.code;
} else if (typeof warningArg === "string") message = warningArg;
if (secondArg && typeof secondArg === "object" && !Array.isArray(secondArg)) {
const options = secondArg;
if (typeof options.type === "string") name = options.type;
if (typeof options.code === "string") code = options.code;
} else {
if (typeof secondArg === "string") name = secondArg;
if (typeof thirdArg === "string") code = thirdArg;
}
return {
name,
code,
message
};
}
/** Installs the global process warning filter once for the current JS realm. */
function installProcessWarningFilter() {
const state = resolveGlobalSingleton(warningFilterKey, () => ({ installed: false }));
if (state.installed) return;
const originalEmitWarning = process.emitWarning.bind(process);
const wrappedEmitWarning = ((...args) => {
if (shouldIgnoreWarning(normalizeWarningArgs(args))) return;
if (args[0] instanceof Error && args[1] && typeof args[1] === "object" && !Array.isArray(args[1])) {
const warning = args[0];
const emitted = Object.assign(new Error(warning.message), {
name: warning.name,
code: warning.code
});
process.emit("warning", emitted);
return;
}
Reflect.apply(originalEmitWarning, process, args);
});
process.emitWarning = wrappedEmitWarning;
state.installed = true;
}
//#endregion
//#region src/infra/node-sqlite.ts
const require$1 = createRequire(import.meta.url);
let validatedSqliteModule;
function resolveSqliteFilesystemPath(pathname) {
if (process.platform !== "win32") return pathname;
return path.toNamespacedPath(path.resolve(pathname));
}
function resolveNodeSqliteLocation(location) {
if (location === "" || location === ":memory:" || location.startsWith("file:")) return location;
return resolveSqliteFilesystemPath(location);
}
/** Preserve native Windows path prefixes before adding SQLite URI parameters. */
function resolveSqliteFileUriPath(pathname, platform) {
if (platform === "win32") {
const namespacedPath = path.win32.toNamespacedPath(path.win32.resolve(pathname));
return `file:${encodeURIComponent(namespacedPath)}`;
}
return pathToFileURL(path.resolve(pathname)).href;
}
/** Open an existing writable database without SQLite's create-if-missing flag. */
function resolveExistingSqliteFileUri(pathname, platform = process.platform) {
return `${resolveSqliteFileUriPath(pathname, platform)}?mode=rw`;
}
function assertSqliteWalResetSafeVersion(version, nodeVersion) {
if (isSqliteWalResetSafeVersion(version)) return;
const variables = process.config?.variables;
const isShared = variables?.node_shared_sqlite === true || variables?.node_shared_sqlite === "true";
throw new Error(`OpenClaw requires SQLite 3.51.3+, 3.50.7+ within 3.50.x, or 3.44.6+ within 3.44.x for WAL safety; Node ${nodeVersion} ${isShared ? "uses shared system" : "embeds"} SQLite ${version}, which is affected by the upstream WAL-reset database corruption bug. ${isShared ? "Upgrade the system SQLite library to one of those safe versions, or use a Node build embedding a safe version." : "Upgrade to Node 24.16.0+ or 26.1.0+ before retrying."}`);
}
function assertSafeSqliteRuntime(sqlite) {
if (validatedSqliteModule === sqlite) return;
const database = new sqlite.DatabaseSync(":memory:");
try {
const row = database.prepare("SELECT sqlite_version() AS version").get();
const version = typeof row?.version === "string" ? row.version : "unknown";
assertSqliteWalResetSafeVersion(version, process.versions.node);
compareValidSemver(version, "3.45.0");
database.prepare("SELECT sqlite_compileoption_used('OMIT_LOAD_EXTENSION') AS omitted").get()?.omitted;
validatedSqliteModule = sqlite;
} finally {
database.close();
}
}
/** Load node:sqlite after installing the process warning filter. */
function requireNodeSqlite() {
installProcessWarningFilter();
try {
ensureSqliteLibrarySelected();
const sqlite = require$1("node:sqlite");
assertSafeSqliteRuntime(sqlite);
return sqlite;
} catch (err) {
const message = formatErrorMessage(err);
throw new Error(`SQLite support is unavailable or unsafe in this Node runtime. ${message}`, { cause: err });
}
}
/** Open node:sqlite through OpenClaw's runtime and filesystem-location boundary. */
function openNodeSqliteDatabase(location, options) {
const sqlite = requireNodeSqlite();
const resolvedLocation = resolveNodeSqliteLocation(location);
const database = options === void 0 ? new sqlite.DatabaseSync(resolvedLocation) : new sqlite.DatabaseSync(resolvedLocation, options);
trackSqliteSchema(database, sqlite);
registerSqliteReaderConnection(database);
return database;
}
//#endregion
//#region src/infra/sqlite-error-diagnostics.ts
const inspectionOperations = resolveGlobalSingleton(Symbol.for("openclaw.sqliteInspectionOperations"), () => /* @__PURE__ */ new WeakMap());
const nativeOpenFailures = resolveGlobalSingleton(Symbol.for("openclaw.sqliteNativeOpenFailures"), () => /* @__PURE__ */ new WeakSet());
function markSqliteNativeOpenFailure(error) {
if (error !== null && typeof error === "object") nativeOpenFailures.add(error);
}
/** Record the native effect without changing its error or tagging surrounding authority checks. */
function withSqliteNativeOpen(open) {
try {
return open();
} catch (error) {
markSqliteNativeOpenFailure(error);
throw error;
}
}
function markSqliteInspectionOperation(error, operation) {
if (error !== null && typeof error === "object" && !inspectionOperations.has(error)) inspectionOperations.set(error, operation);
return error;
}
const SQLITE_LOCK_ERROR_CODES = /* @__PURE__ */ new Set(["SQLITE_BUSY", "SQLITE_LOCKED"]);
const SQLITE_BUSY_RESULT_CODE = 5;
const SQLITE_LOCKED_RESULT_CODE = 6;
const SQLITE_CORRUPT_RESULT_CODE = 11;
const SQLITE_NOTADB_RESULT_CODE = 26;
const SQLITE_PRIMARY_RESULT_CODE_MASK = 255;
function sqliteErrorCode(error) {
const code = asOptionalObjectRecord(error)?.code;
return typeof code === "string" ? code : void 0;
}
function sqliteExtendedResultCode(error) {
const errcode = asOptionalObjectRecord(error)?.errcode;
return typeof errcode === "number" && Number.isInteger(errcode) ? errcode : void 0;
}
function sqlitePrimaryResultCode(error) {
const errcode = sqliteExtendedResultCode(error);
return errcode === void 0 ? void 0 : errcode & SQLITE_PRIMARY_RESULT_CODE_MASK;
}
function isSqliteLockError(error) {
const code = sqliteErrorCode(error);
if (code !== void 0 && SQLITE_LOCK_ERROR_CODES.has(code)) return true;
const primaryCode = sqlitePrimaryResultCode(error);
return primaryCode === SQLITE_BUSY_RESULT_CODE || primaryCode === SQLITE_LOCKED_RESULT_CODE;
}
/** Report proven file damage (corrupt page or non-database header), not transient failure. */
function isSqliteCorruptionError(error) {
const primaryCode = sqlitePrimaryResultCode(error);
return primaryCode === SQLITE_CORRUPT_RESULT_CODE || primaryCode === SQLITE_NOTADB_RESULT_CODE;
}
//#endregion
//#region src/infra/file-descriptor.ts
/** Strict field equality; callers own any platform-specific identity tolerance. */
function sameFileMutationFingerprint(left, right) {
return left.birthtimeNs === right.birthtimeNs && left.ctimeNs === right.ctimeNs && left.dev === right.dev && left.ino === right.ino && left.mtimeNs === right.mtimeNs && left.size === right.size;
}
/** Maps the borrowed-descriptor digest to OpenClaw's persisted artifact fields. */
function hashFileDescriptorSync(fd, maxBytes) {
const { digest, bytes } = sha256FileSync(fd, { maxBytes });
return {
sha256: digest,
sizeBytes: bytes
};
}
//#endregion
//#region src/infra/sqlite-file-generation.ts
function assertRegularFile(stat) {
if (!stat.isFile()) throw new Error("SQLite generation target must be a regular file");
}
function sameFileState(left, right) {
return sameFileIdentity(left, right) && left.birthtimeNs === right.birthtimeNs && left.ctimeNs === right.ctimeNs && left.mtimeNs === right.mtimeNs && left.size === right.size;
}
function fingerprintFile(pathname) {
const fd = fsSync.openSync(pathname, "r");
try {
const before = fsSync.fstatSync(fd, { bigint: true });
assertRegularFile(before);
const { sha256 } = hashFileDescriptorSync(fd);
const after = fsSync.fstatSync(fd, { bigint: true });
const current = fsSync.statSync(pathname, { bigint: true });
if (!sameFileState(before, after) || !sameFileState(after, current)) throw new Error(`SQLite generation target changed while hashing: ${pathname}`);
return {
birthtimeNs: after.birthtimeNs,
ctimeNs: after.ctimeNs,
dev: after.dev,
ino: after.ino,
mtimeNs: after.mtimeNs,
sha256,
size: after.size
};
} finally {
fsSync.closeSync(fd);
}
}
function readOptionalFile(pathname) {
try {
return fingerprintFile(pathname);
} catch (error) {
if (error.code === "ENOENT") return;
throw error;
}
}
function readGeneration(pathname) {
const database = fingerprintFile(pathname);
const journal = readOptionalFile(`${pathname}-journal`);
const wal = readOptionalFile(`${pathname}-wal`);
return {
database,
...journal ? { journal } : {},
...wal ? { wal } : {}
};
}
function readStableSqliteFileGeneration(pathname) {
const first = readGeneration(pathname);
const second = readGeneration(pathname);
if (!sameSqliteFileGeneration(first, second)) throw new Error(`SQLite file generation changed while reading: ${pathname}`);
return second;
}
function sameFileFingerprint(left, right) {
return sameFileMutationFingerprint(left, right) && left.sha256 === right.sha256;
}
function sameOptionalFileFingerprint(left, right) {
return left === void 0 ? right === void 0 : right !== void 0 && sameFileFingerprint(left, right);
}
function sameSqliteFileGeneration(left, right) {
return sameFileFingerprint(left.database, right.database) && sameOptionalFileFingerprint(left.journal, right.journal) && sameOptionalFileFingerprint(left.wal, right.wal);
}
function parseFileFingerprint(value) {
if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("SQLite file fingerprint must be an object");
const fingerprint = value;
for (const field of [
"birthtimeNs",
"ctimeNs",
"dev",
"ino",
"mtimeNs",
"size"
]) if (typeof fingerprint[field] !== "string" || !/^-?\d+$/u.test(fingerprint[field])) throw new Error(`SQLite file fingerprint ${field} is invalid`);
if (typeof fingerprint.sha256 !== "string" || !/^[a-f0-9]{64}$/u.test(fingerprint.sha256)) throw new Error("SQLite file fingerprint sha256 is invalid");
return {
birthtimeNs: BigInt(fingerprint.birthtimeNs),
ctimeNs: BigInt(fingerprint.ctimeNs),
dev: BigInt(fingerprint.dev),
ino: BigInt(fingerprint.ino),
mtimeNs: BigInt(fingerprint.mtimeNs),
sha256: fingerprint.sha256,
size: BigInt(fingerprint.size)
};
}
function parseSqliteFileGeneration(serialized) {
const value = JSON.parse(serialized);
if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("SQLite file generation must be an object");
const generation = value;
return {
database: parseFileFingerprint(generation.database),
...generation.journal === void 0 ? {} : { journal: parseFileFingerprint(generation.journal) },
...generation.wal === void 0 ? {} : { wal: parseFileFingerprint(generation.wal) }
};
}
//#endregion
//#region src/infra/sqlite-integrity.ts
/** The gate includes the driver's check, awaited lifetime, and admission revalidation. */
function* sqliteIntegrityCheckSteps(database, databaseLabel, diagnostics, tables) {
const startedAt = performance$1.now();
const check = {
database,
databaseLabel,
tables
};
if (diagnostics) {
check.timing = {};
diagnostics.integrityGateMode = tables ? "tables" : "full";
delete diagnostics.integrityTableTimings;
delete diagnostics.integrityTableTotals;
delete diagnostics.integrityCheckSyncMs;
delete diagnostics.integrityOutsideCheckMs;
delete diagnostics.integrityWorkerCheckMs;
delete diagnostics.integrityWorkerLifetimeMs;
delete diagnostics.integrityOutsideWorkerMs;
}
try {
yield check;
if (diagnostics) diagnostics.integrityGateOutcome = "healthy";
} catch (error) {
if (diagnostics) diagnostics.integrityGateOutcome = "failed";
throw error;
} finally {
if (diagnostics) {
diagnostics.integrityGateMs = Math.floor(performance$1.now() - startedAt);
if (check.timing?.tables) {
diagnostics.integrityTableTotals = {};
for (const table of check.timing.tables) {
const total = diagnostics.integrityTableTotals[table.check] ??= {
tableCount: 0,
elapsedMs: 0
};
total.tableCount += 1;
total.elapsedMs += table.elapsedMs;
}
diagnostics.integrityTableTimings = check.timing.tables.toSorted((left, right) => right.elapsedMs - left.elapsedMs).slice(0, 10);
}
if (check.timing?.syncElapsedMs !== void 0) {
diagnostics.integrityCheckSyncMs = Math.floor(check.timing.syncElapsedMs);
diagnostics.integrityOutsideCheckMs = diagnostics.integrityGateMs - diagnostics.integrityCheckSyncMs;
}
if (check.timing?.workerCheckElapsedMs !== void 0) diagnostics.integrityWorkerCheckMs = Math.floor(check.timing.workerCheckElapsedMs);
if (check.timing?.workerLifetimeElapsedMs !== void 0) {
diagnostics.integrityWorkerLifetimeMs = Math.floor(check.timing.workerLifetimeElapsedMs);
diagnostics.integrityOutsideWorkerMs = diagnostics.integrityGateMs - diagnostics.integrityWorkerLifetimeMs;
}
}
}
}
/** Measure only the calling driver's synchronous check, excluding admission and resumption. */
function runSqliteIntegrityCheckSync(check) {
const timing = check.timing;
const startedAt = timing ? performance$1.now() : 0;
try {
assertSqliteIntegrity(check.database, check.databaseLabel, "integrity_check", check.tables, timing);
} finally {
if (timing) timing.syncElapsedMs = performance$1.now() - startedAt;
}
}
/** Run the same admission steps synchronously when the caller cannot yield. */
function runSqliteIntegrityOperationSync(operation) {
let step = operation.next();
while (!step.done) {
try {
runSqliteIntegrityCheckSync(step.value);
} catch (error) {
step = operation.throw(error);
continue;
}
step = operation.next();
}
return step.value;
}
const MAX_REPORTED_FOREIGN_KEY_VIOLATIONS = 5;
var SqliteRepairableForeignKeyError = class extends Error {
constructor(databaseLabel, orphanCount) {
super(`SQLite foreign_key_check failed for ${databaseLabel}: repairable task_delivery_state.task_id references task_runs.task_id cascade-owned orphans (${orphanCount} rows). Run openclaw doctor --fix to migrate this legacy state before retrying.`);
this.name = "SqliteRepairableForeignKeyError";
this.repair = {
kind: "task-delivery-orphans",
relation: "task_delivery_state.task_id",
parentTable: "task_runs",
orphanCount
};
}
};
/** Return whether a named integrity failure proves persistent database damage. */
function isTerminalSqliteIntegrityError(error) {
if (error.name !== "SqliteIntegrityError") return false;
if (!error.cause) return true;
return isSqliteCorruptionError(error.cause);
}
/** Require structural, table/index, and referential consistency before trusting a database. */
function assertSqliteIntegrity(database, databaseLabel, check = "integrity_check", tables, timing) {
if (tables) {
if (timing) timing.tables = [];
for (const entry of tables) {
const startedAt = performance$1.now();
try {
runSqliteCheck(database, databaseLabel, entry.check, entry.table);
runSqliteForeignKeyCheck(database, databaseLabel, entry.table);
} finally {
timing?.tables?.push({
...entry,
elapsedMs: Math.floor(performance$1.now() - startedAt)
});
}
}
return { integrityCheck: "ok" };
}
const integrityCheck = runSqliteCheck(database, databaseLabel, check);
runSqliteForeignKeyCheck(database, databaseLabel);
return { integrityCheck };
}
/** Require table and associated index consistency before trusting indexed reads. */
function assertSqliteTableIntegrity(database, databaseLabel, tableName) {
runSqliteCheck(database, `${databaseLabel} table ${tableName}`, "integrity_check", tableName);
}
function runSqliteCheck(database, databaseLabel, pragma, tableName) {
const argument = tableName ? `('${tableName.replaceAll("'", "''")}')` : "";
let rows;
try {
rows = database.prepare(`PRAGMA ${pragma}${argument};`).all();
} catch (error) {
throw createSqliteIntegrityError(`SQLite ${pragma} failed for ${databaseLabel}: ${error instanceof Error ? error.message : String(error)}`, error);
}
const results = rows.map((row) => row[pragma] ?? Object.values(row)[0]);
if (results.length === 1 && results[0] === "ok") return "ok";
throw createSqliteIntegrityError(`SQLite ${pragma} failed for ${databaseLabel}: ${results.map((result) => String(result)).join("; ") || "no result"}. Run openclaw doctor --fix for explicit repair; if repair is refused, preserve the database and WAL and restore a verified backup.`);
}
function runSqliteForeignKeyCheck(database, databaseLabel, table) {
let violationCount = 0;
let repairable = true;
let taskDeliveryForeignKeyId;
const violations = [];
try {
const argument = table ? `('${table.replaceAll("'", "''")}')` : "";
const statement = database.prepare(`PRAGMA foreign_key_check${argument};`);
statement.setReadBigInts(true);
for (const violation of statement.iterate()) {
violationCount += 1;
retainSortedForeignKeyViolation(violations, violation);
if (repairable) {
if (violation.table === "task_delivery_state" && violation.parent === "task_runs") {
taskDeliveryForeignKeyId ??= readTaskDeliveryCascadeForeignKeyId(database);
repairable = violation.fkid === taskDeliveryForeignKeyId;
} else repairable = false;
}
}
} catch (error) {
throw createSqliteIntegrityError(`SQLite foreign_key_check failed for ${databaseLabel}: ${error instanceof Error ? error.message : String(error)}`, error);
}
if (violations.length === 0) return;
if (repairable) throw new SqliteRepairableForeignKeyError(databaseLabel, violationCount);
const details = violations.map(formatSqliteForeignKeyViolation);
if (violationCount > MAX_REPORTED_FOREIGN_KEY_VIOLATIONS) details.push("additional violations omitted");
throw createSqliteIntegrityError(`SQLite foreign_key_check failed for ${databaseLabel}: ${details.join("; ")}`);
}
function readTaskDeliveryCascadeForeignKeyId(database) {
const statement = database.prepare("PRAGMA foreign_key_list(task_delivery_state);");
statement.setReadBigInts(true);
const foreignKeys = statement.all();
const taskKey = foreignKeys.find((key) => key.table === "task_runs" && key.from === "task_id" && key.to === "task_id" && key.on_delete === "CASCADE");
return taskKey && typeof taskKey.id === "bigint" && foreignKeys.filter((key) => key.id === taskKey.id).length === 1 ? taskKey.id : void 0;
}
function createSqliteIntegrityError(message, cause) {
const error = cause === void 0 ? new Error(message) : new Error(message, { cause });
error.name = "SqliteIntegrityError";
return error;
}
function retainSortedForeignKeyViolation(retained, violation) {
retained.push(violation);
retained.sort(compareSqliteForeignKeyViolations);
if (retained.length > MAX_REPORTED_FOREIGN_KEY_VIOLATIONS) retained.pop();
}
function compareSqliteForeignKeyViolations(left, right) {
const tableOrder = Buffer.compare(Buffer.from(left.table), Buffer.from(right.table));
if (tableOrder !== 0) return tableOrder;
if (left.rowid === null || right.rowid === null) {
if (left.rowid !== right.rowid) return left.rowid === null ? -1 : 1;
} else if (left.rowid !== right.rowid) return left.rowid < right.rowid ? -1 : 1;
const parentOrder = Buffer.compare(Buffer.from(left.parent), Buffer.from(right.parent));
if (parentOrder !== 0) return parentOrder;
if (left.fkid === right.fkid) return 0;
return left.fkid < right.fkid ? -1 : 1;
}
function formatSqliteForeignKeyViolation(violation) {
const row = violation.rowid === null ? "row without rowid" : `row ${violation.rowid.toString()}`;
return `${violation.table} ${row} references ${violation.parent} (foreign key ${violation.fkid.toString()})`;
}
//#endregion
//#region src/infra/sqlite-terminal-open-latch.ts
function generationMatchesPath(pathname, expected) {
try {
return sameSqliteFileGeneration(expected, readStableSqliteFileGeneration(pathname));
} catch {
return false;
}
}
/**
* Per-path latch for terminal database-open failures (newer schema, proven
* corruption). Recording quarantines the path: any live handle is closed and
* every later open fails fast until doctor repairs the file and clears it.
*/
function createSqliteTerminalOpenLatch(options) {
const failures = /* @__PURE__ */ new Map();
return {
/** Read the owner's recorded fact without running filesystem or database inspection. */
peek: (pathname) => failures.get(path.resolve(pathname))?.error,
get: (pathname) => {
const resolvedPath = path.resolve(pathname);
const failure = failures.get(resolvedPath);
if (!failure) return;
if (failure.generation && !generationMatchesPath(resolvedPath, failure.generation)) {
failures.delete(resolvedPath);
return;
}
return failure.error;
},
async getAsync(pathname, isCurrentGeneration) {
const resolvedPath = path.resolve(pathname);
for (;;) {
const failure = failures.get(resolvedPath);
if (!failure?.generation) return failure?.error;
const current = await isCurrentGeneration(resolvedPath, failure.generation);
if (failures.get(resolvedPath) !== failure) continue;
if (!current) {
failures.delete(resolvedPath);
return;
}
return failure.error;
}
},
record: (pathname, error, generation) => {
const resolvedPath = path.resolve(pathname);
if (generation && !generationMatchesPath(resolvedPath, generation)) return false;
failures.set(resolvedPath, {
error,
...generation ? { generation } : {}
});
options.closeByPath(resolvedPath, error);
if (generation && !generationMatchesPath(resolvedPath, generation)) {
failures.delete(resolvedPath);
return false;
}
return true;
},
clear: (pathname) => {
failures.delete(path.resolve(pathname));
},
clearAll: (rootPath) => {
for (const pathname of failures.keys()) if (rootPath === void 0 || isPathInside$1(rootPath, pathname)) failures.delete(pathname);
}
};
}
//#endregion
//#region src/infra/sqlite-transaction.ts
const DEFAULT_SLOW_BUSY_WAIT_MS = 1e3;
const DEFAULT_SLOW_TRANSACTION_HOLD_MS = 1e3;
const abortedTransactionSymbol = Symbol.for("openclaw.sqliteAbortedTransaction");
function assertTransactionUsable(db) {
const aborted = db[abortedTransactionSymbol];
if (aborted) throw aborted.error;
}
const transactionLog = createSubsystemLogger("sqlite/transaction");
const writeAdmissionServices = resolveGlobalSingleton(Symbol.for("openclaw.sqliteWriteAdmissionServices"), () => /* @__PURE__ */ new Map());
const writeAdmissionLocations = /* @__PURE__ */ new WeakMap();
function writeAdmissionLocation(database) {
const cached = writeAdmissionLocations.get(database);
if (cached !== void 0) return cached;
const location = database.location();
const canonical = location === null ? null : normalizeDatabasePath(location);
writeAdmissionLocations.set(database, canonical);
return canonical;
}
/** Locations come from the retained native owner; registration grants no write authority. */
function retainSqliteWriteAdmissionService(nativeLocations, service) {
const registrations = [...new Set(nativeLocations.map(normalizeDatabasePath))].map((location) => {
const services = writeAdmissionServices.get(location) ?? /* @__PURE__ */ new Set();
const retained = () => service();
services.add(retained);
writeAdmissionServices.set(location, services);
return {
location,
services,
retained
};
});
return () => {
for (const { location, services, retained } of registrations) {
services.delete(retained);
if (services.size === 0 && writeAdmissionServices.get(location) === services) writeAdmissionServices.delete(location);
}
};
}
function execNativeBegin(db, diagnostics) {
const startedAt = Date.now();
diagnostics.nativeAttempts += 1;
try {
db.exec("BEGIN IMMEDIATE");
} finally {
diagnostics.nativeMs += Date.now() - startedAt;
}
}
function beginImmediateTransaction(db, diagnostics) {
const location = writeAdmissionServices.size > 0 ? writeAdmissionLocation(db) : null;
const services = location === null ? void 0 : writeAdmissionServices.get(location);
if (!services) {
execNativeBegin(db, diagnostics);
return;
}
const deadline = performance.now() + readSqliteBusyTimeout(db);
while (true) try {
runWithSqliteBusyTimeout(db, Math.min(25, Math.max(0, Math.ceil(deadline - performance.now()))), () => execNativeBegin(db, diagnostics));
return;
} catch (error) {
if (!isSqliteLockError(error) || performance.now() >= deadline) throw error;
for (const service of services) {
const startedAt = Date.now();
diagnostics.serviceCalls += 1;
try {
service();
} finally {
diagnostics.serviceMs += Date.now() - startedAt;
}
}
if (performance.now() >= deadline) throw error;
}
}
function assertSyncTransactionResult(value) {
if (isPromiseLike(value)) throw new Error("SQLite write transactions must be synchronous; Promise returns are not supported.");
}
function slowBusyWaitThresholdMs(options) {
if (options?.busyTimeoutMs === void 0 || options.busyTimeoutMs <= 0) return DEFAULT_SLOW_BUSY_WAIT_MS;
return Math.min(DEFAULT_SLOW_BUSY_WAIT_MS, options.busyTimeoutMs);
}
function slowTransactionHoldThresholdMs(options) {
return options?.slowTransactionHoldMs ?? DEFAULT_SLOW_TRANSACTION_HOLD_MS;
}
function transactionLogger(options) {
return options?.logger ?? transactionLog;
}
function transactionDiagnosticLabels(db, options) {
let database = options?.databaseLabel;
if (!database) try {
database = db ? db.location() ?? ":memory:" : "unavailable";
} catch {
database = "unavailable";
}
return {
database,
operation: options?.operationLabel || captureSqliteReaderOwner()?.operation || "unlabeled"
};
}
function logSlowTransactionHold(params) {
if (params.elapsedMs < slowTransactionHoldThresholdMs(params.options)) return;
transactionLogger(params.options).warn("slow SQLite transaction hold", {
async: false,
...transactionDiagnosticLabels(params.db, params.options),
elapsedMs: params.elapsedMs,
isMainThread,
mode: params.mode,
pid: process.pid,
threadId,
thresholdMs: slowTransactionHoldThresholdMs(params.options)
});
}
function logSlowTransactionStep(params) {
if (params.elapsedMs < slowBusyWaitThresholdMs(params.options)) return;
transactionLogger(params.options).warn("slow SQLite transaction step", {
async: false,
...params.options?.busyTimeoutMs !== void 0 ? { busyTimeoutMs: params.options.busyTimeoutMs } : {},
...transactionDiagnosticLabels(params.db, params.options),
elapsedMs: params.elapsedMs,
isMainThread,
pid: process.pid,
step: params.step,
threadId,
...params.beginAdmission ? { beginAdmission: { ...params.beginAdmission } } : {}
});
}
function execTimedTransactionStep(params) {
const startedAt = Date.now();
const beginAdmission = params.sql === "BEGIN IMMEDIATE" ? {
nativeAttempts: 0,
nativeMs: 0,
serviceCalls: 0,
serviceMs: 0
} : void 0;
try {
if (beginAdmission) beginImmediateTransaction(params.db, beginAdmission);
else params.db.exec(params.sql);
const elapsedMs = Date.now() - startedAt;
logSlowTransactionStep({
beginAdmission,
db: params.db,
elapsedMs,
options: params.options,
step: params.step
});
return elapsedMs;
} catch (error) {
const elapsedMs = Date.now() - startedAt;
if (isSqliteLockError(error) && shouldReportSqliteLockFailure(params.db)) {
const sqliteErrcode = sqliteExtendedResultCode(error);
const sqlitePrimaryCode = sqlitePrimaryResultCode(error);
transactionLogger(params.options).warn("SQLite transaction lock wait failed", {
async: false,
...params.options?.busyTimeoutMs !== void 0 ? { busyTimeoutMs: params.options.busyTimeoutMs } : {},
...transactionDiagnosticLabels(params.db, params.options),
code: sqliteErrorCode(error),
elapsedMs,
failureKind: "lock-contention",
isMainThread,
pid: process.pid,
...sqliteErrcode !== void 0 ? { sqliteErrcode } : {},
...sqlitePrimaryCode !== void 0 ? { sqlitePrimaryCode } : {},
step: params.step,
threadId,
...beginAdmission ? { beginAdmission: { ...beginAdmission } } : {}
});
}
throw error;
}
}
function beginTransaction(db, options, mode) {
execTimedTransactionStep({
db,
options,
sql: mode === "immediate" ? "BEGIN IMMEDIATE" : "BEGIN",
step: "begin"
});
}
function commitImmediateTransaction(db, options) {
execTimedTransactionStep({
db,
options,
sql: "COMMIT",
step: "commit"
});
}
function discardUnsafeConnection(db, error) {
db[abortedTransactionSymbol] ??= { error };
discardSqliteTransactionState(db, error);
clearNodeSqliteKyselyCacheForDatabase(db);
try {
db.close();
} catch {}
}
function abortImmediateTransaction(db, error, commitStarted) {
if (db[abortedTransactionSymbol]) return;
try {
if (!commitStarted && db.isOpen && !db.isTransaction) {
discardSqliteTransactionState(db, error);
return;
}
db.exec("ROLLBACK");
} catch {
discardUnsafeConnection(db, error);
}
}
function runSqliteTransactionSync(db, operation, mode, options) {
assertTransactionUsable(db);
if (db.isTransaction) {
db.exec("SAVEPOINT openclaw_tx_nested");
try {
const result = operation();
assertSyncTransactionResult(result);
assertTransactionUsable(db);
db.exec("RELEASE SAVEPOINT openclaw_tx_nested");
return result;
} catch (error) {
const failure = db[abortedTransactionSymbol];
if (failure) throw failure.error;
try {
db.exec("ROLLBACK TO SAVEPOINT openclaw_tx_nested");
db.exec("RELEASE SAVEPOINT openclaw_tx_nested");
} catch {
discardUnsafeConnection(db, error);
}
throw error;
}
}
beginTransaction(db, options, mode);
const transactionStartedAt = Date.now();
let commitStarted = false;
try {
const result = operation();
assertSyncTransactionResult(result);
assertTransactionUsable(db);
commitStarted = true;
if (options?.withCommit) assertSyncTransactionResult(options.withCommit(() => commitImmediateTransaction(db, options)));
else commitImmediateTransaction(db, options);
return result;
} catch (error) {
abortImmediateTransaction(db, error, commitStarted);
assertTransactionUsable(db);
throw error;
} finally {
try {
logSlowTransactionHold({
db,
elapsedMs: Date.now() - transactionStartedAt,
mode,
options
});
} catch {}
}
}
/** Run synchronous reads against one deferred SQLite snapshot. */
function runSqliteDeferredTransactionSync(db, operation, options) {
return runSqliteTransactionSync(db, operation, "deferred", options);
}
function runSqliteImmediateTransactionSync(db, operation, options) {
return runSqliteTransactionSync(db, operation, "immediate", options);
}
//#endregion
//#region src/infra/sqlite-wal-write-admission.ts
const admissions = resolveGlobalSingleton(Symbol.for("openclaw.sqliteWalWriteAdmissions"), () => /* @__PURE__ */ new WeakMap());
function registerSqliteWalWorkerMaintenance(database, execute, cancel) {
admissions.set(database, {
execute,
cancel
});
}
function cancelSqliteWalWriteAdmission(database) {
return admissions.get(database)?.cancel?.();
}
function createSqliteWalMaintenanceScheduler(database, operation, prepare, observe, onError, pageBudget) {
let pending;
return () => {
if (!pending) {
const run = async () => {
let remaining = pageBudget;
while (remaining > 0) {
const request = prepare(remaining);
if (!request) return;
let result;
const admitted = () => {
if (prepare(remaining)) result = operation(request);
};
const admission = admissions.get(database);
if (admission?.execute) {
result = await admission.execute(request);
if (!prepare(remaining)) return;
if (result?.checkpoint) observe(result.checkpoint);
} else if (admission?.admit) await admission.admit(admitted);
else admitted();
const reclaimed = result?.reclaimedPages ?? 0;
remaining -= reclaimed;
if (reclaimed <= 0 || remaining <= 0) return;
await setImmediate();
}
};
pending = run().catch((error) => {
if (prepare(pageBudget)) onError(error);
}).finally(() => {
pending = void 0;
});
}
return pending;
};
}
//#endregion
//#region packages/normalization-core/src/mountinfo-path.ts
const MOUNT_PATH_OCTAL_ESCAPE_RE = /\\([0-7]{3})/g;
/** Decodes an octal-escaped path field from a Linux procfs mount table. */
function decodeMountInfoPath(value) {
return value.replace(MOUNT_PATH_OCTAL_ESCAPE_RE, (_match, octal) => String.fromCharCode(Number.parseInt(octal, 8)));
}
//#endregion
//#region src/infra/sqlite-number.ts
const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
function coerceRequiredSqliteNumber(value) {
return typeof value === "bigint" ? Number(value) : value;
}
/** Converts a SQLite number or safely representable bigint column into a JavaScript number. */
function normalizeSqliteNumber(value) {
if (typeof value === "bigint") {
if (value > MAX_SAFE_INTEGER_BIGINT || value < -MAX_SAFE_INTEGER_BIGINT) return;
return Number(value);
}
return typeof value === "number" ? value : void 0;
}
//#endregion
//#region src/infra/sqlite-wal-checkpoint.ts
const checkpointListeners = resolveGlobalSingleton(Symbol.for("openclaw.sqliteWalCheckpointListeners"), () => /* @__PURE__ */ new Set());
/** A relayed worker result adds host observations without claiming visibility into other threads. */
function observeSqliteWalCheckpointHealth(databasePath, health) {
const { activeReaders: previousReaders, readerDiagnostics: previousDiagnostics, ...observation } = health;
if (health.state === "complete") return observation;
const { activeReaders, ...local } = readSqliteReaderDiagnosticsForPath(databasePath);
return {
...observation,
activeReaders: [...(previousReaders ?? []).filter((reader) => reader.threadId !== local.threadId), ...activeReaders].toSorted((left, right) => right.ageMs - left.ageMs).slice(0, 8),
readerDiagnostics: [...(previousDiagnostics ?? []).filter((diagnostic) => diagnostic.threadId !== local.threadId), local].slice(-8)
};
}
function notifyCheckpoint(databasePath, snapshot) {
for (const listener of checkpointListeners) try {
listener({
databasePath: sqliteReaderDatabasePathKey(databasePath),
health: structuredClone(snapshot.health),
observedAtNs: snapshot.observedAtNs
});
} catch {}
}
function sqliteFileBytes(pathname) {
try {
return fsSync.statSync(pathname).size;
} catch (error) {
if (hasErrnoCode(error, "ENOENT")) return 0;
throw error;
}
}
function readCheckpointResult(row) {
const [busy, logFrames, checkpointedFrames] = Object.values(row ?? {}).map((value) => normalizeSqliteNumber(typeof value === "number" || typeof value === "bigint" ? value : null));
if (busy === void 0 || logFrames === void 0 || checkpointedFrames === void 0) throw new Error("SQLite returned an invalid WAL checkpoint result");
return {
busy,
logFrames,
checkpointedFrames
};
}
function checkpoint(database, mode) {
return database.prepare(`PRAGMA wal_checkpoint(${mode});`).get();
}
/** The maintenance lifecycle owns this checkpoint result and its last observation. */
function createSqliteWalCheckpoint(database, options, journalSizeLimitBytes) {
let snapshot;
const checkpointObservation = () => ({
state: "error",
observedAtMs: Date.now(),
walBytes: null,
databaseBytes: null,
logFrames: null,
checkpointedFrames: null,
lastCompletedAtMs: snapshot?.health.lastCompletedAtMs ?? null,
consecutiveBlocked: 0,
warning: true
});
const recordCheckpointError = (error, observation = checkpointObservation()) => {
const failed = {
...observation,
observedAtMs: Date.now(),
state: "error",
consecutiveBlocked: 0,
warning: true,
error: formatErrorMessage(error)
};
snapshot = {
observedAtNs: process.hrtime.bigint(),
health: options.databasePath ? observeSqliteWalCheckpointHealth(options.databasePath, failed) : failed
};
if (options.databasePath) notifyCheckpoint(options.databasePath, snapshot);
options.onCheckpointError?.(error);
};
const recordCheckpoint = (mode, row) => {
const observedAtNs = process.hrtime.bigint();
const observation = checkpointObservation();
let busy;
let sizeError;
try {
const { busy: busyResult, logFrames, checkpointedFrames } = readCheckpointResult(row);
busy = busyResult !== 0;
observation.logFrames = logFrames;
observation.checkpointedFrames = checkpointedFrames;
observation.state = busy || checkpointedFrames < logFrames ? "blocked" : "complete";
if (observation.state === "complete") observation.lastCompletedAtMs = observation.observedAtMs;
else observation.consecutiveBlocked = (snapshot?.health.consecutiveBlocked ?? 0) + 1;
if (options.databasePath) try {
observation.databaseBytes = sqliteFileBytes(options.databasePath);
observation.walBytes = sqliteFileBytes(`${options.databasePath}-wal`);
} catch (error) {
sizeError = error;
observation.error = formatErrorMessage(error);
}
observation.warning = observation.state === "blocked" && (observation.consecutiveBlocked >= 2 || observation.walBytes !== null && observation.databaseBytes !== null && observation.walBytes > Math.max(2 * observation.databaseBytes, journalSizeLimitBytes));
snapshot = {
observedAtNs,
health: options.databasePath ? observeSqliteWalCheckpointHealth(options.databasePath, observation) : observation
};
if (options.databasePath) notifyCheckpoint(options.databasePath, snapshot);
} catch (error) {
recordCheckpointError(error, observation);
return false;
}
if (observation.error !== void 0) options.onCheckpointError?.(sizeError);
if (busy || observation.warning) {
const label = options.databaseLabel ?? "sqlite database";
options.onCheckpointError?.(/* @__PURE__ */ new Error(`${label} WAL checkpoint ${mode} ${busy ? "remained busy" : "blocked by a reader"}`));
}
return observation.state === "complete";
};
return {
adopt(received) {
if (snapshot && snapshot.observedAtNs >= received.observedAtNs) return;
snapshot = structuredClone(received);
if (options.databasePath) {
snapshot.health = observeSqliteWalCheckpointHealth(options.databasePath, snapshot.health);
notifyCheckpoint(options.databasePath, snapshot);
}
},
checkpoint(mode) {
try {
return recordCheckpoint(mode, checkpoint(database, mode));
} catch (error) {
recordCheckpointError(error);
return false;
}
},
recordError: recordCheckpointError,
inspectIdle() {
const { busy, logFrames, checkpointedFrames } = readCheckpointResult(checkpoint(database, "PASSIVE"));
return busy === 0 && logFrames >= 0 && checkpointedFrames >= 0 && checkpointedFrames <= logFrames;
},
get health() {
return snapshot ? structuredClone(snapshot.health) : void 0;
},
get snapshot() {
return snapshot ? structuredClone(snapshot) : void 0;
}
};
}
//#endregion
//#region src/infra/sqlite-wal-reclamation.ts
const VACUUM_UNIT_TARGET_MS = 25;
const vacuumPageBudgets = /* @__PURE__ */ new WeakMap();
function createSqliteWalReclamationResult() {
return {
checkpointCompleted: false,
freePagesBefore: null,
remainingFreePages: null,
checkpointCalls: 0,
checkpointIncomplete: 0,
checkpointMs: 0,
checkpointMaxMs: 0,
queryMs: 0,
vacuumMs: 0,
vacuumPasses: 0,
vacuumPagesRequested: 0
};
}
/** One online unit never waits for readers or adds vacuum frames behind a blocked checkpoint. */
function reclaimSqliteWalFreePages(database, runCheckpoint, options) {
const result = createSqliteWalReclamationResult();
const checkpoint = () => {
options.beforeMutation?.();
const startedAt = performance$1.now();
try {
const mode = options.checkpointMode ?? "TRUNCATE";
let completed = runCheckpoint(mode);
result.checkpointCalls++;
if (!completed && mode === "TRUNCATE") {
options.beforeMutation?.();
completed = runCheckpoint("PASSIVE");
result.checkpointCalls++;
}
result.checkpointCompleted = completed;
result.checkpointIncomplete += Number(!completed);
return completed;
} finally {
const elapsed = performance$1.now() - startedAt;
result.checkpointMs += elapsed;
result.checkpointMaxMs = Math.max(result.checkpointMaxMs, elapsed);
}
};
const freePages = () => {
const startedAt = performance$1.now();
try {
return Number(database.prepare("PRAGMA freelist_count").get()?.freelist_count ?? 0);
} finally {
result.queryMs += performance$1.now() - startedAt;
}
};
return runWithSqliteBusyTimeout(database, 0, () => {
if (!checkpoint()) return result;
const before = freePages();
result.freePagesBefore = before;
result.remainingFreePages = before;
if (!Number.isSafeInteger(before) || before <= 0) return result;
const pages = Math.min(vacuumPageBudgets.get(database) ?? 8, before, options.maxPages ?? 512);
if (!Number.isSafeInteger(pages) || pages <= 0) throw new Error("SQLite page reclamation requires a positive integer page limit");
const startedAt = performance$1.now();
let entered = false;
let completed = false;
try {
runSqliteImmediateTransactionSync(database, () => {
entered = true;
options.beforeMutation?.();
result.vacuumPasses++;
result.vacuumPagesRequested += pages;
database.exec(`PRAGMA incremental_vacuum(${pages});`);
options.onCommit?.();
}, {
busyTimeoutMs: 0,
operationLabel: "incremental-vacuum"
});
completed = true;
} catch (error) {
if (entered || !isSqliteLockError(error)) throw error;
return result;
} finally {
const elapsedMs = performance$1.now() - startedAt;
result.vacuumMs += elapsedMs;
if (completed) vacuumPageBudgets.set(database, Math.max(1, Math.min(512, pages * 2, Math.floor(pages * VACUUM_UNIT_TARGET_MS / Math.max(elapsedMs, .001)))));
}
options.afterCommit?.();
if (checkpoint()) result.remainingFreePages = freePages();
return result;
});
}
//#endregion
//#region src/infra/sqlite-wal-split-brain.ts
const PROC_SELF_FD_PATH = "/proc/self/fd";
const SQLITE_WAL_SPLIT_BRAIN_FATAL_MESSAGE = "SQLite WAL sidecar identity mismatch; terminating without SQLite cleanup";
function statSqliteSidecarTarget(pathname) {
try {
return fsSync.statSync(pathname, { bigint: true });
} catch (error) {
if (hasErrnoCode(error, "ENOENT")) return;
throw error;
}
}
function isSqliteWalSidecarSplitBrain(descriptor, target) {
return descriptor.nlink === 0n || !target || descriptor.dev !== target.dev || descriptor.ino !== target.ino;
}
function detectSqliteWalSplitBrain(databasePath) {
let descriptors;
try {
descriptors = fsSync.readdirSync(PROC_SELF_FD_PATH);
} catch (error) {
if (hasErrnoCode(error, "ENOENT")) return;
throw error;
}
const sidecarPaths = [`${databasePath}-wal`, `${databasePath}-shm`];
for (const descriptorName of descriptors) {
const descriptorPath = path.join(PROC_SELF_FD_PATH, descriptorName);
let linkedPath;
try {
linkedPath = fsSync.readlinkSync(descriptorPath);
} catch (error) {
if (hasErrnoCode(error, "ENOENT")) continue;
throw error;
}
const sidecarPath = sidecarPaths.find((candidate) => linkedPath === candidate || linkedPath === `${candidate} (deleted)`);
if (!sidecarPath) continue;
let descriptor;
try {
descriptor = fsSync.fstatSync(Number(descriptorName), { bigint: true });
} catch (error) {
if (hasErrnoCode(error, "EBADF") || hasErrnoCode(error, "ENOENT")) continue;
throw error;
}
try {
if (fsSync.readlinkSync(descriptorPath) !== linkedPath) continue;
} catch (error) {
if (hasErrnoCode(error, "ENOENT")) continue;
throw error;
}
const target = statSqliteSidecarTarget(sidecarPath);
if (!isSqliteWalSidecarSplitBrain(descriptor, target)) continue;
return {
event: "sqlite_wal_sidecar_identity_mismatch",
databasePath,
descriptorDevice: descriptor.dev.toString(),
descriptorInode: descriptor.ino.toString(),
sidecarPath,
...target ? {
targetDevice: target.dev.toString(),
targetInode: target.ino.toString()
} : {}
};
}
}
function terminateForSqliteWalSplitBrain(splitBrain, databaseLabel) {
try {
fsSync.writeSync(2, `${JSON.stringify({
level: "fatal",
subsystem: "infra/sqlite-wal",
message: SQLITE_WAL_SPLIT_BRAIN_FATAL_MESSAGE,
...splitBrain,
databaseLabel,
pid: process.pid
})}\n`);
} catch {}
try {
process.kill(process.pid, "SIGKILL");
} finally {
process.abort();
}
}
//#endregion
//#region src/infra/sqlite-wal.ts
const DEFAULT_SQLITE_WAL_AUTOCHECKPOINT_PAGES = 1e3;
const DEFAULT_SQLITE_WAL_CHECKPOINT_INTERVAL_MS = 18e5;
const DEFAULT_SQLITE_WAL_JOURNAL_SIZE_LIMIT_BYTES = 67108864;
const LINUX_NFS_SUPER_MAGIC = 26985;
const LINUX_SMB_SUPER_MAGIC = 20859;
const LINUX_CIFS_SUPER_MAGIC = 4283649346;
const LINUX_SMB2_SUPER_MAGIC = 4266872130;
const LINUX_V9FS_SUPER_MAGIC = 16914839;
const PROC_MOUNTINFO_PATH = "/proc/self/mountinfo";
const MOUNT_COMMAND_TIMEOUT_MS = 1e3;
const NETWORK_FILESYSTEM_TYPES = /* @__PURE__ */ new Set([
"cifs",
"smbfs",
"smb2",
"smb3"
]);
const CROSS_VM_FILESYSTEM_TYPES = /* @__PURE__ */ new Set([
"virtiofs",
"fuse.virtiofs",
"9p",
"9p2000.l"
]);
const JOURNAL_MODE_RETRY_INTERVAL_MS = 10;
const JOURNAL_MODE_RETRY_SLEEP = new Int32Array(new SharedArrayBuffer(4));
const log$1 = createSubsystemLogger("infra/sqlite-wal");
const runInSqliteMaintenanceContext = AsyncLocalStorage.snapshot();
function configureSqliteBusyTimeout(db, busyTimeoutMs) {
const normalizedTimeoutMs = normalizeSqliteNonNegativeInteger(busyTimeoutMs, "busyTimeoutMs");
db.exec(`PRAGMA busy_timeout = ${normalizedTimeoutMs};`);
return normalizedTimeoutMs;
}
function enableIncrementalAutoVacuumForFreshDatabase(db) {
if (db.prepare("PRAGMA page_count").get()?.page_count === 0) db.exec("PRAGMA auto_vacuum = INCREMENTAL;");
}
/**
* Configure lock retry before inspecting or mutating a fresh database header.
* Concurrent first opens can otherwise fail before schema transactions begin.
*/
function configureSqlitePreSchemaPragmas(db, options = {}) {
if (options.busyTimeoutMs !== void 0) configureSqliteBusyTimeout(db, options.busyTimeoutMs);
enableIncrementalAutoVacuumForFreshDatabase(db);
}
function findExistingVolumePaths(targetPath) {
let current = path.resolve(targetPath);
while (true) {
let stats;
try {
stats = fsSync.statSync(current);
} catch {
const parent = path.dirname(current);
if (parent === current) return null;
current = parent;
continue;
}
const existingPath = fsSync.realpathSync(current);
return {
canonicalPath: stats.isDirectory() ? existingPath : path.dirname(existingPath),
originalPath: stats.isDirectory() ? current : path.dirname(current)
};
}
}
function parseProcMountInfoEntries(contents) {
const entries = [];
for (const line of contents.split("\n")) {
const separator = line.indexOf(" - ");
if (separator === -1) continue;
const fields = line.slice(0, separator).split(" ");
const suffixFields = line.slice(separator + 3).split(" ");
const mountPoint = fields[4];
const fsType = suffixFields[0];
if (mountPoint && fsType) entries.push({
mountPoint: decodeMountInfoPath(mountPoint),
fsType,
...suffixFields[1] ? { source: decodeMountInfoPath(suffixFields[1]) } : {}
});
}
return entries;
}
function parseMountCommandEntries(contents) {
const entries = [];
for (const line of contents.split("\n")) {
const match = /^(.+) on (.+) type ([^,\s)]+) \(/.exec(line) ?? /^(.+) on (.+) \(([^,\s)]+)/.exec(line);
if (match) {
const [, source, mountPoint, fsType] = match;
if (source && mountPoint && fsType) entries.push({
source,
mountPoint,
fsType
});
}
}
return entries;
}
function isMountCommandTimeout(error) {
return error !== null && typeof error === "object" && "code" in error && error.code === "ETIMEDOUT";
}
function readMountEntries() {
try {
return {
ok: true,
value: parseProcMountInfoEntries(fsSync.readFileSync(PROC_MOUNTINFO_PATH, "utf8"))
};
} catch {}
try {
return {
ok: true,
value: parseMountCommandEntries(String(process.getBuiltinModule("node:child_process").execFileSync("mount", [], {
killSignal: "SIGKILL",
timeout: MOUNT_COMMAND_TIMEOUT_MS
})))
};
} catch (error) {
return isMountCommandTimeout(error) ? {
ok: false,
error: "timeout"
} : {
ok: true,
value: []
};
}
}
function isPathWithinMount(targetPath, mountPoint) {
const resolvedTarget = path.resolve(targetPath);
const resolvedMountPoint = path.resolve(mountPoint);
return resolvedTarget === resolvedMountPoint || resolvedMountPoint === path.parse(resolvedMountPoint).root || resolvedTarget.startsWith(`${resolvedMountPoint}${path.sep}`);
}
function isSshfsMountSource(source) {
if (!source) return false;
const normalized = source.toLowerCase();
return normalized === "sshfs" || normalized.startsWith("sshfs#") || normalized.startsWith("sshfs@") || /^(?:[^/\s:]+@)?[^/\s:]+:.*/u.test(source);
}
function resolveMountTypeJournalPolicy(entry) {
const normalized = entry.fsType.toLowerCase();
if (normalized.startsWith("nfs") || NETWORK_FILESYSTEM_TYPES.has(normalized)) return "rollback";
if (CROSS_VM_FILESYSTEM_TYPES.has(normalized) || normalized.startsWith("9p")) return "rollback";
if (normalized === "fuse.sshfs") return "unsupported";
if ((normalized === "macfuse" || normalized === "osxfuse") && isSshfsMountSource(entry.source)) return "unsupported";
return "wal";
}
function resolveMountEntryJournalPolicy(targetPath, mountEntries) {
const mountEntry = mountEntries.filter((entry) => isPathWithinMount(targetPath, entry.mountPoint)).toSorted((a, b) => b.mountPoint.length - a.mountPoint.length)[0];
return mountEntry ? resolveMountTypeJournalPolicy(mountEntry) : "wal";
}
function combineMountEntryJournalPolicies(targetPaths) {
const mountResult = readMountEntries();
if (!mountResult.ok) {
const [originalPath, canonicalPath] = targetPaths;
if (process.platform === "darwin" && originalPath === canonicalPath) try {
if (probeTreeClone(canonicalPath) === "apfs") return "wal";
} catch {}
return "rollback";
}
const policies = new Set(targetPaths.map((targetPath) => resolveMountEntryJournalPolicy(targetPath, mountResult.value)));
if (policies.has("unsupported")) return "unsupported";
return policies.has("rollback") ? "rollback" : "wal";
}
function isWindowsUncPath(targetPath) {
return /^\\\\\?\\UNC\\[^\\]+\\[^\\]+/i.test(targetPath) || /^\\\\(?![?.]\\)[^\\]+\\[^\\]+/.test(targetPath);
}
function isWindowsDrivePath(targetPath) {
return /^[A-Za-z]:[\\/]/.test(targetPath) || /^\\\\\?\\[A-Za-z]:[\\/]/i.test(targetPath);
}
function resolvePathJournalPolicy(targetPath) {
if (process.platform === "win32") {
const normalizedTargetPath = path.win32.normalize(targetPath);
if (isWindowsUncPath(normalizedTargetPath)) return "rollback";
if (isWindowsDrivePath(normalizedTargetPath)) try {
return isWindowsUncPath(path.win32.normalize(fsSync.realpathSync.native(targetPath))) ? "rollback" : "wal";
} catch {
return "rollback";
}
}
const checkedPaths = findExistingVolumePaths(targetPath);
if (!checkedPaths) return "wal";
const mountLookupPaths = [checkedPaths.originalPath, checkedPaths.canonicalPath];
if (typeof fsSync.statfsSync !== "function") return combineMountEntryJournalPolicies(mountLookupPaths);
try {
const filesystemType = fsSync.statfsSync(checkedPaths.canonicalPath).type;
if (filesystemType === LINUX_NFS_SUPER_MAGIC || filesystemType === LINUX_SMB_SUPER_MAGIC || filesystemType === LINUX_CIFS_SUPER_MAGIC || filesystemType === LINUX_SMB2_SUPER_MAGIC || filesystemType === LINUX_V9FS_SUPER_MAGIC) return "rollback";
} catch {
return combineMountEntryJournalPolicies(mountLookupPaths);
}
return combineMountEntryJournalPolicies(mountLookupPaths);
}
function readJournalModeResult(row) {
if (!row || typeof row !== "object") return null;
const record = row;
const value = record.journal_mode ?? Object.values(record)[0];
return typeof value === "string" ? value.toLowerCase() : null;
}
function hasInMemoryMainDatabase(db) {
return db.prepare("PRAGMA database_list;").all().find((row) => row.name === "main")?.file === "";
}
function requireRollbackJournalMode(db, options) {
const journalMode = readJournalModeResult(db.prepare("PRAGMA journal_mode = DELETE;").get());
if (journalMode !== "delete") {
const label = options.databaseLabel ?? "sqlite database";
const location = options.databasePath ? ` at ${options.databasePath}` : "";
throw new Error(`${label}${location} is on a network-backed volume but SQLite kept journal_mode=${journalMode ?? "unknown"}; refusing to continue with WAL on network storage.`);
}
}
function enableWalJournalMode(db, retryTimeoutMs, options) {
const deadline = performance$1.now() + retryTimeoutMs;
let restoreBusyTimeout = false;
try {
while (true) try {
db.exec("PRAGMA journal_mode = WAL;");
const journalMode = readJournalModeResult(db.prepare("PRAGMA journal_mode;").get());
if (journalMode === "wal") return true;
if (journalMode === "memory" && hasInMemoryMainDatabase(db)) return false;
const label = options.databaseLabel ?? "sqlite database";
const location = options.databasePath ? ` at ${options.databasePath}` : "";
throw new Error(`${label}${location} could not enable WAL; SQLite kept journal_mode=${journalMode ?? "unknown"}.`);
} catch (error) {
const remainingMs = Math.max(0, deadline - performance$1.now());
if (!isSqliteLockError(error) || remainingMs <= 0) throw error;
if (!restoreBusyTimeout) {
configureSqliteBusyTimeout(db, 0);
restoreBusyTimeout = true;
}
Atomics.wait(JOURNAL_MODE_RETRY_SLEEP, 0, 0, Math.min(JOURNAL_MODE_RETRY_INTERVAL_MS, remainingMs));
}
} finally {
if (restoreBusyTimeout) configureSqliteBusyTimeout(db, retryTimeoutMs);
}
}
function enableMacosCheckpointFullfsync(db) {
if (process.platform !== "darwin") return;
try {
db.exec("PRAGMA checkpoint_fullfsync = 1;");
} catch {}
}
function refuseUnsupportedFilesystem(options) {
const label = options.databaseLabel ?? "sqlite database";
const location = options.databasePath ? ` at ${options.databasePath}` : "";
throw new Error(`${label}${location} is on SSHFS, which cannot safely coordinate SQLite writes across mounts; refusing to open the database.`);
}
/** Configure safe journaling pragmas and return a handle for checkpoint/close maintenance. */
function configureSqliteWalMaintenance(db, options = {}) {
const busyTimeoutMs = options.busyTimeoutMs === void 0 ? 0 : configureSqliteBusyTimeout(db, options.busyTimeoutMs);
const autoCheckpointPages = normalizeSqliteNonNegativeInteger(options.autoCheckpointPages ?? DEFAULT_SQLITE_WAL_AUTOCHECKPOINT_PAGES, "autoCheckpointPages");
const checkpointIntervalMs = normalizeSqliteNonNegativeInteger(options.checkpointIntervalMs ?? DEFAULT_SQLITE_WAL_CHECKPOINT_INTERVAL_MS, "checkpointIntervalMs");
const timerIntervalMs = Math.min(checkpointIntervalMs, MAX_TIMER_TIMEOUT_MS);
const checkpointMode = options.checkpointMode ?? "TRUNCATE";
const periodicCheckpointMode = options.checkpointMode ?? "PASSIVE";
const journalPolicy = options.databasePath ? resolvePathJournalPolicy(options.databasePath) : "wal";
if (journalPolicy === "unsupported") refuseUnsupportedFilesystem(options);
if (journalPolicy === "rollback") requireRollbackJournalMode(db, options);
if (journalPolicy === "rollback" || !enableWalJournalMode(db, busyTimeoutMs, options)) return {
checkpoint: () => true,
reclaimFreePages: (reclaimOptions = {}) => reclaimSqliteWalFreePages(db, () => true, reclaimOptions),
close: () => true
};
enableMacosCheckpointFullfsync(db);
db.exec(`PRAGMA wal_autocheckpoint = ${autoCheckpointPages};`);
db.exec(`PRAGMA journal_size_limit = ${DEFAULT_SQLITE_WAL_JOURNAL_SIZE_LIMIT_BYTES};`);
const tripwireDatabasePath = process.platform === "linux" && options.databasePath && fsSync.existsSync(options.databasePath) ? fsSync.realpathSync.native(options.databasePath) : void 0;
let invalidated = false;
let splitBrainDetectionEnabled = Boolean(tripwireDatabasePath);
const checkpointOwner = createSqliteWalCheckpoint(db, options, DEFAULT_SQLITE_WAL_JOURNAL_SIZE_LIMIT_BYTES);
const runCheckpoint = checkpointOwner.checkpoint;
const runMaintenance = (operation) => {
if (invalidated) return false;
try {
return options.runMaintenance ? options.runMaintenance(operation) : operation();
} catch (error) {
checkpointOwner.recordError(error);
return false;
}
};
const checkpoint = () => runMaintenance(() => runCheckpoint(checkpointMode));
const reclaimFreePages = (reclaimOptions = {}) => {
let result;
let failure;
runMaintenance(() => {
try {
result = reclaimSqliteWalFreePages(db, runCheckpoint, reclaimOptions);
return result.checkpointCompleted;
} catch (error) {
failure = { error };
throw error;
}
});
if (failure) throw failure.error;
if (!result) throw new Error("SQLite page reclamation owner is unavailable");
return {
...result,
checkpoint: checkpointOwner.snapshot
};
};
let timer = null;
const maintainPeriodic = (request, admit) => {
if (invalidated) return { reclaimedPages: 0 };
if (request.checkpoint) checkpointOwner.adopt(request.checkpoint);
let reclaimedPages = 0;
runMaintenance(() => {
const reclaimed = reclaimSqliteWalFreePages(db, runCheckpoint, {
checkpointMode: request.checkpointMode,
maxPages: request.maxPages,
beforeMutation: () => admit?.("transaction"),
onCommit: () => admit?.("commit")
});
const checkpointed = reclaimed.checkpointCompleted;
if (checkpointed && reclaimed.freePagesBefore !== null && reclaimed.remainingFreePages !== null) reclaimedPages = Math.min(reclaimed.vacuumPagesRequested, reclaimed.freePagesBefore - reclaimed.remainingFreePages);
if (checkpointed && request.checkpointMode === "PASSIVE" && (checkpointOwner.health?.walBytes ?? 0) > DEFAULT_SQLITE_WAL_JOURNAL_SIZE_LIMIT_BYTES) {
admit?.("transaction");
runWithSqliteBusyTimeout(db, 0, () => runCheckpoint("TRUNCATE"));
}
return checkpointed;
});
return {
reclaimedPages,
checkpoint: checkpointOwner.snapshot
};
};
const maintain = createSqliteWalMaintenanceScheduler(db, maintainPeriodic, (maxPages) => timer && !invalidated ? {
maxPages,
checkpointMode: periodicCheckpointMode,
checkpoint: checkpointOwner.snapshot
} : void 0, checkpointOwner.adopt, (error) => checkpointOwner.recordError(error), 512);
if (timerIntervalMs > 0) {
timer = runInSqliteMaintenanceContext(() => setInterval(() => {
if (!timer || invalidated) return;
if (tripwireDatabasePath && splitBrainDetectionEnabled) {
let splitBrain;
try {
splitBrain = detectSqliteWalSplitBrain(tripwireDatabasePath);
} catch (error) {
splitBrainDetectionEnabled = false;
log$1.warn("SQLite WAL split-brain detection disabled", {
databaseLabel: options.databaseLabel,
databasePath: tripwireDatabasePath,
error: error instanceof Error ? error.message : String(error)
});
}
if (splitBrain) {
invalidated = true;
if (timer) {
clearInterval(timer);
timer = null;
}
terminateForSqliteWalSplitBrain(splitBrain, options.databaseLabel);
}
}
maintain();
}, timerIntervalMs));
timer.unref?.();
}
return {
get health() {
return checkpointOwner.health;
},
checkpoint,
maintainPeriodic,
reclaimFreePages,
inspectIdle: () => runMaintenance(checkpointOwner.inspectIdle) ? "healthy" : "retire",
close: (closeOptions) => {
clearInterval(timer ?? void 0);
timer = null;
cancelSqliteWalWriteAdmission(db);
if (invalidated) return false;
return runMaintenance(() => runCheckpoint(closeOptions?.checkpointMode ?? checkpointMode));
}
};
}
let lastSqliteExitGroup;
function detachEmptySqliteExitGroup(group) {
if (group.pending.size > 0) return;
if (lastSqliteExitGroup === group) lastSqliteExitGroup = void 0;
process.removeListener("exit", group.dispatch);
}
/**
* Register a best-effort exit-time close for a SQLite handle cache. Returns an
* unregister callback the cache's orderly close path must invoke, so tests and
* runtime shutdowns do not accumulate listeners on shared worker processes.
*/
function registerSqliteCacheExitClose(closeAll) {
const registration = {
close: closeAll,
fired: false
};
let group = lastSqliteExitGroup;
if (!group || process.listeners("exit").at(-1) !== group.dispatch) {
const pending = /* @__PURE__ */ new Set([registration]);
const created = {
pending,
dispatch: () => {
const snapshot = [...pending];
for (const entry of snapshot) {
if (entry.fired) continue;
entry.fired = true;
pending.delete(entry);
detachEmptySqliteExitGroup(created);
try {
entry.close();
} catch {}
}
}
};
process.on("exit", created.dispatch);
lastSqliteExitGroup = group = created;
} else group.pending.add(registration);
const owner = group;
return () => {
owner.pending.delete(registration);
detachEmptySqliteExitGroup(owner);
};
}
/** Configure per-connection SQLite pragmas in the safe lock-retry/WAL order. */
function configureSqliteConnectionPragmas(db, options = {}) {
const { foreignKeys, synchronous, ...walOptions } = options;
const maintenance = configureSqliteWalMaintenance(db, walOptions);
try {
if (synchronous) db.exec(`PRAGMA synchronous = ${synchronous};`);
if (foreignKeys) db.exec("PRAGMA foreign_keys = ON;");
return maintenance;
} catch (error) {
try {
maintenance.close();
} catch (closeError) {
throw createSqliteLifecycleAggregateError([error, closeError], "SQLite connection pragma configuration and WAL maintenance cleanup both failed.", error);
}
throw error;
}
}
//#endregion
//#region src/state/openclaw-quarantine-error.ts
const DATABASE_QUARANTINE_READ_CLEANUP_ERROR_NAME = "OpenClawQuarantineReadCleanupError";
const OpenClawQuarantineReadCleanupError = resolveGlobalSingleton(Symbol.for("openclaw.quarantineReadCleanupError"), () => class QuarantineReadCleanupError extends AggregateError {
constructor(errors, quarantine) {
super(errors, "OpenClaw quarantine reader cleanup failed.", { cause: errors[0] });
this.quarantine = quarantine;
this.name = DATABASE_QUARANTINE_READ_CLEANUP_ERROR_NAME;
}
});
//#endregion
//#region src/infra/kysely-sync.ts
const nodeVersion = parseNodeReleaseVersion(process.versions.node);
const supportsRepreparedAll = !process.versions.bun && (nodeVersion?.major === 24 && isNodeVersionAtLeast(nodeVersion, {
major: 24,
minor: 20,
patch: 0
}) || isNodeVersionAtLeast(nodeVersion, {
major: 26,
minor: 6,
patch: 0
}));
const compileOnlySqliteDialect = new SqliteDialect({ database: async () => {
throw new Error("getNodeSqliteKysely() returns a compile-only Kysely facade; use executeSqliteQuerySync() to execute node:sqlite queries.");
} });
function getNodeSqliteKysely(db) {
const existing = kyselyByDatabase.get(db);
if (existing) return existing;
const kysely = new Kysely({ dialect: compileOnlySqliteDialect });
kyselyByDatabase.set(db, kysely);
return kysely;
}
function reportNodeSqliteKyselyQueryError(db, error) {
try {
queryErrorHandlerByDatabase.get(db)?.(error);
} catch {}
}
function throwSqliteIteratorCleanupError(error) {
throw toErrorObject(error, "SQLite iterator cleanup failed");
}
/** Execute a compiled Kysely query synchronously against node:sqlite. */
function executeCompiledSqliteQuerySync(db, compiledQuery, firstRowOnly = false, parameters = compiledQuery.parameters) {
try {
const sql = compiledQuery.sql;
installStatementInvalidation(db);
return executeWithCachedStatement(db, sql, parameters, (statement) => {
if (firstRowOnly && SelectQueryNode.is(compiledQuery.query)) {
const row = statement.get(...parameters);
return { rows: row === void 0 ? [] : [row] };
}
if (SelectQueryNode.is(compiledQuery.query) || statement.columns().length > 0) {
if (supportsRepreparedAll) return { rows: statement.all(...parameters) };
const iterator = statement.iterate(...parameters);
const reader = retainSqliteReader(db, "kysely eager query");
let cleanupError;
let failed = false;
let failure;
const rows = [];
try {
for (const row of iterator) {
reader.progress();
rows.push(row);
}
} catch (error) {
failed = true;
failure = error;
}
try {
iterator.return?.();
} catch (error) {
cleanupError = error;
}
reader.release();
if (failed) throw toErrorObject(failure, "SQLite query failed");
if (cleanupError !== void 0) throw toErrorObject(cleanupError, "SQLite query cleanup failed");
return { rows };
}
statement.setReadBigInts(true);
let outcome;
try {
outcome = statement.run(...parameters);
} finally {
statement.setReadBigInts(false);
}
const { changes, lastInsertRowid } = outcome;
const result = {
numAffectedRows: BigInt(changes),
rows: []
};
if (InsertQueryNode.is(compiledQuery.query) && changes > 0) return {
...result,
insertId: BigInt(lastInsertRowid)
};
return result;
});
} catch (error) {
reportNodeSqliteKyselyQueryError(db, error);
throw error;
}
}
/** Compile and execute a Kysely query synchronously. */
function executeSqliteQuerySync(db, query) {
return executeCompiledSqliteQuerySync(db, query.compile());
}
/** Compile fixed SQL and fresh bindings without taking ownership of a native statement. */
function compileSqliteQueryBindings(build) {
const bindings = /* @__PURE__ */ new Map();
const compiled = build((read) => {
const marker = Symbol("sqlite-query-parameter");
bindings.set(marker, read);
return sql`${marker}`;
}).compile();
const readers = compiled.parameters.map((value) => bindings.get(value) ?? (() => value));
return {
compiled,
bind: (params) => readers.map((read) => read(params))
};
}
/** Compile a fixed query once; bind fresh values through the normal sync executor on each call. */
function prepareSqliteQuerySync(db, build) {
const { compiled, bind } = compileSqliteQueryBindings(build);
return (params) => executeCompiledSqliteQuerySync(db, compiled, false, bind(params));
}
/** Compile and lazily iterate a Kysely query synchronously against node:sqlite. */
function iterateSqliteQuerySync(db, query) {
const owner = captureSqliteReaderOwner();
return (function* () {
const compiledQuery = query.compile();
try {
const statement = db.prepare(compiledQuery.sql);
if (!SelectQueryNode.is(compiledQuery.query) && statement.columns().length === 0) return;
const parameters = compiledQuery.parameters;
const iterator = statement.iterate(...parameters);
const reader = retainSqliteReader(db, "kysely iterator", owner);
let cleanupError;
let failed = false;
try {
for (const row of iterator) {
reader.progress();
yield row;
}
} catch (error) {
failed = true;
throw toErrorObject(error, "SQLite iterator failed");
} finally {
try {
iterator.return?.();
} catch (error) {
cleanupError = error;
}
reader.release();
if (!failed && cleanupError !== void 0) throwSqliteIteratorCleanupError(cleanupError);
}
} catch (error) {
reportNodeSqliteKyselyQueryError(db, error);
throw error;
}
})();
}
/** Execute a Kysely query synchronously and return its first row. */
function executeSqliteQueryTakeFirstSync(db, query) {
return executeCompiledSqliteQuerySync(db, query.compile(), true).rows[0];
}
//#endregion
//#region src/infra/sqlite-schema-contract-assembly.ts
function createSqliteTableContract(tableName, table, tableList, indexes, triggers) {
const normalizedTriggers = triggers.map((trigger) => ({
name: trigger.name,
sql: normalizeSchemaSql(trigger.sql)
}));
const normalizedTableSql = table.sql?.startsWith("CREATE TABLE ") ? null : normalizeSchemaSql(table.sql);
const isVirtualTable = normalizedTableSql !== null && /^CREATE VIRTUAL TABLE /iu.test(normalizedTableSql);
return {
definition: isVirtualTable ? null : parseSqliteTableDefinition(table.sql, tableName),
indexes,
strict: tableList.strict,
triggers: normalizedTriggers,
virtualTableSql: isVirtualTable ? normalizedTableSql : null,
withoutRowid: tableList.wr
};
}
function createSqliteIndexContract(index, schemaSql, rows) {
const terms = rows.map(({ cid, coll, desc, key, name, seqno }) => ({
coll,
desc,
key,
kind: sqliteIndexTermKind(cid),
name,
seqno
}));
return {
name: index.name.startsWith("sqlite_autoindex_") ? null : index.name,
origin: index.origin,
partial: index.partial,
sql: normalizeSchemaSql(schemaSql),
terms,
unique: index.unique
};
}
function sqliteIndexTermKind(cid) {
return cid === -2 ? "expression" : cid === -1 ? "rowid" : "column";
}
function parseSqliteTableDefinition(sql, tableName) {
if (sql === null) throw new Error(`Could not inspect SQLite table definition for ${tableName}.`);
const open = findSqlCharacter(sql, "(");
if (open === -1) throw new Error(`SQLite table ${tableName} has no column definition.`);
const close = findSqlClosingParenthesis(sql, open);
const columns = /* @__PURE__ */ new Map();
const constraints = [];
for (const rawDefinition of splitSqlList(sql.slice(open + 1, close))) {
const definition = normalizeSqlWhitespace(rawDefinition);
if (!definition) continue;
const token = readSqlToken(definition, 0);
if (!token) throw new Error(`SQLite table ${tableName} contains an unreadable definition.`);
if (readTableConstraintKeyword(definition, token)) {
constraints.push(definition);
continue;
}
const columnName = normalizeSqlIdentifier(token.raw);
if (columns.has(columnName)) throw new Error(`SQLite table ${tableName} contains duplicate column ${columnName}.`);
columns.set(columnName, definition);
}
return {
columns: new Map([...columns].toSorted(([left], [right]) => left.localeCompare(right))),
constraints: constraints.toSorted()
};
}
//#endregion
//#region src/infra/sqlite-schema-issues.ts
/** A completed inspection proved schema drift; native read failures retain their own type. */
var SqliteSchemaMismatchError = class extends Error {
constructor(..._args) {
super(..._args);
this.name = "SqliteSchemaMismatchError";
}
};
function defaultIssueMessage(code, objectName) {
const tableName = objectName.split(".", 1)[0];
switch (code) {
case "missing-table": return `missing table ${objectName}`;
case "missing-column":
case "unexpected-column":
case "column-definition-drift": return `column definitions differ for ${tableName}`;
case "table-constraint-drift": return `table constraints differ for ${objectName}`;
case "table-definition-drift": return `table definition differs for ${objectName}`;
case "missing-or-drifted-index": return `missing or drifted index ${objectName}`;
case "unexpected-unique-index": return `unexpected unique index ${objectName}`;
case "missing-or-drifted-trigger": return `missing or drifted trigger ${objectName}`;
case "unexpected-trigger": return `unexpected trigger ${objectName}`;
case "virtual-table-definition-drift": return `virtual table definition differs for ${objectName}`;
case "table-options-drift": return `table options differ for ${objectName}`;
}
throw new Error("Unsupported SQLite schema issue code", { cause: code });
}
function createSqliteSchemaIssue(code, objectName, message) {
return {
code,
objectName,
message: message ?? defaultIssueMessage(code, objectName)
};
}
function legacySqliteSchemaIssueMessages(issues) {
const isColumnIssue = (issue) => issue.code === "column-definition-drift" || issue.code === "missing-column" || issue.code === "unexpected-column";
const columnIssueTables = new Set(issues.filter(isColumnIssue).map((issue) => issue.objectName.split(".", 1)[0]));
return [...new Set(issues.filter((issue) => issue.code !== "table-constraint-drift" || !columnIssueTables.has(issue.objectName)).map((issue) => issue.message))];
}
function throwSqliteSchemaMismatches(databaseLabel, mismatches) {
const shown = mismatches.slice(0, 8);
if (mismatches.length > shown.length) shown.push(`${mismatches.length - shown.length} additional mismatch(es)`);
throw new SqliteSchemaMismatchError(`SQLite schema is incomplete or noncanonical for ${databaseLabel}: ${shown.join("; ")}; run openclaw doctor --fix to repair it.`);
}
//#endregion
//#region src/infra/sqlite-schema-contract.ts
const schemaContractCache = /* @__PURE__ */ new Map();
/** Reuse actual table facts only within one unchanged read transaction on this connection. */
function createSqliteTableContractReader(database) {
const tables = /* @__PURE__ */ new Map();
return (tableName) => {
if (!tables.has(tableName)) tables.set(tableName, collectSqliteTableContract(database, tableName));
return tables.get(tableName);
};
}
/**
* Require every object from one committed schema while allowing unrelated
* tables and indexes that do not replace a canonical object.
*/
function assertSqliteSchemaContains(database, databaseLabel, schemaSql, compatibility = {}, readTable) {
const issues = collectSqliteSchemaIssues(database, schemaSql, compatibility, readTable);
if (issues.length > 0) throwSqliteSchemaMismatches(databaseLabel, legacySqliteSchemaIssueMessages(issues));
}
/** Collect stable, machine-readable differences from one committed schema. */
function collectSqliteSchemaIssues(database, schemaSql, compatibility = {}, readTable) {
return runSqlitePinnedReadSnapshotSync(database, () => collectSqliteSchemaIssuesInSnapshot(database, schemaSql, compatibility, readTable));
}
function collectSqliteSchemaIssuesInSnapshot(database, schemaSql, compatibility, readTable) {
const expected = getSqliteSchemaContract(schemaSql);
const allowedMissingTables = new Set(compatibility.allowedMissingTables ?? []);
const allowedMissingIndexes = new Set(compatibility.allowedMissingIndexes ?? []);
const issues = [];
const add = (code, objectName, message) => {
issues.push(createSqliteSchemaIssue(code, objectName, message));
};
for (const [tableName, expectedTable] of expected) {
const actualTable = readTable ? readTable(tableName) : collectSqliteTableContract(database, tableName);
if (!actualTable) {
if (allowedMissingTables.has(tableName)) continue;
add("missing-table", tableName);
continue;
}
issues.push(...compareTableDefinitions(tableName, actualTable.definition, expectedTable.definition, compatibility, !allowedMissingTables.has(tableName)));
const actualIndexFingerprints = new Set(actualTable.indexes.map((index) => JSON.stringify(index)));
const expectedIndexFingerprints = /* @__PURE__ */ new Set();
for (const expectedIndex of expectedTable.indexes) {
const fingerprint = JSON.stringify(expectedIndex);
expectedIndexFingerprints.add(fingerprint);
if (!actualIndexFingerprints.has(fingerprint)) {
const objectName = expectedIndex.name ?? tableName;
if (expectedIndex.name && allowedMissingIndexes.has(expectedIndex.name) && !database.prepare("SELECT 1 FROM main.sqlite_schema WHERE type = 'index' AND name = ? COLLATE NOCASE LIMIT 1").get(expectedIndex.name)) continue;
add("missing-or-drifted-index", objectName, `missing or drifted index ${expectedIndex.name ?? `on ${tableName}`}`);
}
}
for (const actualIndex of actualTable.indexes) if (actualIndex.unique === 1 && !expectedIndexFingerprints.has(JSON.stringify(actualIndex))) add("unexpected-unique-index", actualIndex.name ?? tableName, `unexpected unique index ${actualIndex.name ?? `on ${tableName}`}`);
const optionalCanonicalTriggerGroups = collectOptionalCanonicalTriggerGroups(database, compatibility, tableName);
const optionalCanonicalTriggers = optionalCanonicalTriggerGroups.flatMap((group) => group.triggers);
const allowedMissingCanonicalTriggers = optionalCanonicalTriggerGroups.filter((group) => group.optional).flatMap((group) => group.triggers);
for (const expectedTrigger of expectedTable.triggers) {
if (allowedMissingCanonicalTriggers.some((canonicalTrigger) => canonicalTrigger.name === expectedTrigger.name)) continue;
if (!containsTrigger(actualTable.triggers, expectedTrigger)) add("missing-or-drifted-trigger", expectedTrigger.name);
}
for (const triggerGroup of optionalCanonicalTriggerGroups) {
const isPresent = actualTable.triggers.some((actualTrigger) => triggerGroup.triggers.some((canonicalTrigger) => actualTrigger.name === canonicalTrigger.name));
if (triggerGroup.optional && !isPresent) continue;
for (const canonicalTrigger of triggerGroup.triggers) if (!containsTrigger(actualTable.triggers, canonicalTrigger)) add("missing-or-drifted-trigger", canonicalTrigger.name);
}
for (const actualTrigger of actualTable.triggers) if (!containsTrigger(expectedTable.triggers, actualTrigger) && !containsTrigger(optionalCanonicalTriggers, actualTrigger)) add("unexpected-trigger", actualTrigger.name);
if (actualTable.virtualTableSql !== expectedTable.virtualTableSql) add("virtual-table-definition-drift", tableName);
if (actualTable.strict !== expectedTable.strict || actualTable.withoutRowid !== expectedTable.withoutRowid) add("table-options-drift", tableName);
}
return issues;
}
/** Require stable canonical tables before a version-specific additive migration. */
function assertSqliteSchemaTablesPresent(database, databaseLabel, schemaSql, options = {}) {
const allowedMissingTables = new Set(options.allowedMissingTables ?? []);
const requiredTables = getCanonicalSqliteTableNames(schemaSql).filter((tableName) => !allowedMissingTables.has(tableName));
const missingTables = [];
const batchSize = 500;
for (let offset = 0; offset < requiredTables.length; offset += batchSize) {
const tables = requiredTables.slice(offset, offset + batchSize);
const expected = tables.map((_table, ordinal) => `(${ordinal}, ?)`).join(", ");
const present = database.prepare(`WITH expected(ordinal, name) AS (VALUES ${expected})
SELECT ordinal FROM expected
WHERE EXISTS (
SELECT 1 FROM main.sqlite_schema
WHERE type = 'table' AND name = expected.name LIMIT 1
)`).all(...tables);
const presentOrdinals = new Set(present.map((row) => row.ordinal));
for (const [ordinal, tableName] of tables.entries()) if (!presentOrdinals.has(ordinal)) missingTables.push(`missing table ${tableName}`);
}
if (missingTables.length > 0) throwSqliteSchemaMismatches(databaseLabel, missingTables);
}
/** Return every explicit named index owned by one committed schema. */
function getCanonicalSqliteNamedIndexContracts(schemaSql) {
const schema = getSqliteSchemaContract(schemaSql);
const indexes = [];
for (const [tableName, table] of schema) for (const fingerprint of table.indexes) {
if (fingerprint.name === null || fingerprint.sql === null || fingerprint.origin !== "c") continue;
indexes.push({
definition: readCanonicalIndexDefinition(fingerprint),
fingerprint,
name: fingerprint.name,
tableName,
unique: fingerprint.unique === 1
});
}
return indexes;
}
/** Return every table owned by one committed schema. */
function getCanonicalSqliteTableNames(schemaSql) {
return [...getSqliteSchemaContract(schemaSql).keys()];
}
/** Inspect one explicit main-schema index using the canonical schema fingerprint shape. */
function collectSqliteNamedIndexContract(database, indexName) {
const row = database.prepare(`
SELECT tbl_name FROM (
SELECT name, sql, tbl_name FROM main.sqlite_schema WHERE type = 'index' AND name = ?
)
`).get(indexName);
if (!row || typeof row.tbl_name !== "string") return;
const index = database.prepare(`PRAGMA main.index_list(${quoteSqliteIdentifier(row.tbl_name)})`).all()?.find((candidate) => candidate.name === indexName);
return index ? collectSqliteIndexContract(database, index) : void 0;
}
function collectOptionalCanonicalTriggerGroups(database, compatibility, tableName) {
return (compatibility.optionalCanonicalTriggerGroups ?? []).filter((group) => group.tableName === tableName).map((group) => ({
optional: !group.optionalWhenTableMissing || !database.prepare("SELECT 1 FROM main.sqlite_schema WHERE type = 'table' AND name = ? LIMIT 1").get(group.optionalWhenTableMissing),
triggers: group.triggers.map((trigger) => ({
name: trigger.name,
sql: normalizeOptionalCanonicalTriggerSql(trigger.sql)
}))
}));
}
function normalizeOptionalCanonicalTriggerSql(sql) {
return normalizeSchemaSql(sql)?.replace(/^(CREATE TRIGGER) main\./iu, "$1 ") ?? null;
}
function getSqliteSchemaContract(schemaSql) {
let expected = schemaContractCache.get(schemaSql);
if (!expected) {
expected = buildSqliteSchemaContract(schemaSql);
schemaContractCache.set(schemaSql, expected);
}
return expected;
}
function collectCanonicalSqliteFacts(database) {
const tableOptions = database.prepare("PRAGMA table_list").all();
if (tableOptions.some((row) => {
const name = row.name.toLowerCase();
return name === "pragma_index_list" || name === "pragma_index_xinfo";
})) return;
const indexes = database.prepare(`
SELECT CAST(t.rowid AS TEXT) AS table_id, i.seq AS index_seq,
i.name, i.origin, i.partial, i."unique", d.sql
FROM sqlite_schema AS t
CROSS JOIN pragma_index_list(t.name) AS i
LEFT JOIN sqlite_schema AS d ON d.type = 'index' AND d.name = i.name
WHERE t.type = 'table' AND t.name NOT LIKE 'sqlite_%'
`).all();
const terms = database.prepare(`
SELECT CAST(t.rowid AS TEXT) AS table_id, i.seq AS index_seq,
x.seqno, x.cid, x.name, x."desc", x.coll, x."key"
FROM sqlite_schema AS t
CROSS JOIN pragma_index_list(t.name) AS i
CROSS JOIN pragma_index_xinfo(i.name) AS x
WHERE t.type = 'table' AND t.name NOT LIKE 'sqlite_%'
ORDER BY t.rowid, i.seq, x.seqno
`).all();
const triggers = database.prepare(`
SELECT tbl_name, name, sql FROM sqlite_schema WHERE type = 'trigger' ORDER BY tbl_name, name
`).all();
return {
tableOptions,
indexes: groupCanonicalRows(indexes, (row) => row.table_id),
terms: groupCanonicalRows(terms, (row) => row.table_id),
triggers: groupCanonicalRows(triggers, (row) => row.tbl_name)
};
}
function groupCanonicalRows(rows, key) {
const groups = /* @__PURE__ */ new Map();
for (const row of rows) {
const name = key(row);
const group = groups.get(name);
if (group) group.push(row);
else groups.set(name, [row]);
}
return groups;
}
function buildSqliteSchemaContract(schemaSql) {
const database = openNodeSqliteDatabase(":memory:");
try {
database.exec(schemaSql);
const rows = database.prepare(`
SELECT CAST(rowid AS TEXT) AS table_id, name, sql
FROM sqlite_schema
WHERE type = 'table'
AND name NOT LIKE 'sqlite_%'
ORDER BY name
`).all();
if (rows.length === 0) return /* @__PURE__ */ new Map();
const facts = collectCanonicalSqliteFacts(database);
if (!facts) return new Map(rows.map((table) => [table.name, collectSqliteTableContractFromRow(database, table.name, table)]));
return new Map(rows.map((table) => {
const tableList = facts.tableOptions.find((entry) => entry.name === table.name);
if (!tableList) throw new Error(`Could not inspect SQLite table options for ${table.name}.`);
const termsByIndex = groupCanonicalRows(facts.terms.get(table.table_id) ?? [], (term) => term.index_seq);
const indexes = (facts.indexes.get(table.table_id) ?? []).map((index) => createSqliteIndexContract(index, index.sql, termsByIndex.get(index.index_seq) ?? [])).toSorted(compareJson);
return [table.name, createSqliteTableContract(table.name, table, tableList, indexes, facts.triggers.get(table.name) ?? [])];
}));
} finally {
database.close();
}
}
function readCanonicalIndexDefinition(index) {
if (index.name === null || index.sql === null) throw new Error("Canonical SQLite named index is missing its schema definition.");
const prefix = (index.unique === 1 ? /^CREATE\s+UNIQUE\s+INDEX\s+/iu : /^CREATE\s+INDEX\s+/iu).exec(index.sql);
if (!prefix) throw new Error(`Canonical SQLite index ${index.name} has an unreadable definition.`);
const name = readSqlToken(index.sql, prefix[0].length);
if (!name || normalizeSqlIdentifier(name.raw) !== index.name.toLowerCase()) throw new Error(`Canonical SQLite index ${index.name} has an unexpected schema name.`);
const definition = index.sql.slice(name.end).trim();
if (!/^ON\s+/iu.test(definition)) throw new Error(`Canonical SQLite index ${index.name} has an unreadable target.`);
return definition;
}
function collectSqliteTableContract(database, tableName) {
const table = executeWithCachedStatement(database, "SELECT name, sql FROM sqlite_schema WHERE type = 'table' AND name = ?", [tableName], (statement) => statement.get(tableName));
if (!table) return;
return collectSqliteTableContractFromRow(database, tableName, table);
}
function collectSqliteTableContractFromRow(database, tableName, table) {
const quotedTable = quoteSqliteIdentifier(tableName);
const tableList = database.prepare(`PRAGMA table_list(${quotedTable})`).all().find((entry) => entry.name === tableName);
if (!tableList) throw new Error(`Could not inspect SQLite table options for ${tableName}.`);
return createSqliteTableContract(tableName, table, tableList, database.prepare(`PRAGMA index_list(${quotedTable})`).all().map((index) => collectSqliteIndexContract(database, index)).toSorted(compareJson), executeWithCachedStatement(database, `
SELECT name, sql
FROM sqlite_schema
WHERE type = 'trigger' AND tbl_name = ?
ORDER BY name
`, [tableName], (statement) => statement.all(tableName)));
}
function compareTableDefinitions(tableName, actual, expected, compatibility, allowCompatibleAdditiveColumns) {
const issues = [];
const add = (code, objectName) => {
issues.push(createSqliteSchemaIssue(code, objectName));
};
if (!actual || !expected) {
if (actual !== expected) add("table-definition-drift", tableName);
return issues;
}
const allowedMissingColumns = new Set(compatibility.allowedMissingColumns ?? []);
for (const [columnName, definition] of actual.columns) if (!expected.columns.has(columnName)) {
if (allowCompatibleAdditiveColumns && compatibility.allowCompatibleAdditiveColumns && isCompatibleAdditiveColumnDefinition(definition)) continue;
add("unexpected-column", `${tableName}.${columnName}`);
}
for (const [columnName, expectedDefinition] of expected.columns) {
const objectName = `${tableName}.${columnName}`;
const actualDefinition = actual.columns.get(columnName);
if (actualDefinition === void 0) {
if (!allowedMissingColumns.has(objectName)) add("missing-column", objectName);
continue;
}
if (actualDefinition === expectedDefinition) continue;
if (!(compatibility.allowedColumnDefinitions?.[objectName] ?? []).some((definition) => normalizeSqlWhitespace(definition) === actualDefinition)) add("column-definition-drift", objectName);
}
if (JSON.stringify(actual.constraints) !== JSON.stringify(expected.constraints)) add("table-constraint-drift", tableName);
return issues;
}
const SQLITE_STRICT_DATATYPES = /* @__PURE__ */ new Set([
"ANY",
"BLOB",
"INT",
"INTEGER",
"REAL",
"TEXT"
]);
function isCompatibleAdditiveColumnDefinition(definition) {
const name = readSqlToken(definition, 0);
const type = name ? readSqlToken(definition, name.end) : null;
return Boolean(type?.keyword && SQLITE_STRICT_DATATYPES.has(type.keyword) && definition.slice(type.end).trim().length === 0);
}
function collectSqliteIndexContract(database, index) {
const row = executeWithCachedStatement(database, "SELECT sql FROM sqlite_schema WHERE type = 'index' AND name = ?", [index.name], (statement) => statement.get(index.name));
const terms = database.prepare(`PRAGMA index_xinfo(${quoteSqliteIdentifier(index.name)})`).all();
return createSqliteIndexContract(index, typeof row?.sql === "string" ? row.sql : null, terms);
}
function containsTrigger(triggers, expected) {
return triggers.some((trigger) => trigger.name === expected.name && trigger.sql === expected.sql);
}
function compareJson(left, right) {
return JSON.stringify(left).localeCompare(JSON.stringify(right));
}
function readSqliteSchemaCookie(database) {
return database.prepare("PRAGMA schema_version").get()?.schema_version;
}
//#endregion
//#region src/infra/sqlite-strict.ts
const DEFAULT_STRICT_MIGRATION_BUSY_TIMEOUT_MS = 5e3;
const STRICT_MIGRATION_TABLE_PREFIX = "__openclaw_strict_migration_";
const SQLITE_ROWID_ALIASES = [
"_rowid_",
"rowid",
"oid"
];
function readMainTableList(db) {
return db.prepare("PRAGMA table_list").all().filter((row) => row.schema === "main" && typeof row.name === "string" && !row.name.startsWith("sqlite_"));
}
function readTableColumns$1(db, tableName) {
return db.prepare(`PRAGMA table_xinfo(${quoteSqliteIdentifier(tableName)})`).all();
}
function readVisibleColumns(db, tableName) {
return readTableColumns$1(db, tableName).filter((row) => Number(row.hidden ?? 0) === 0).map((row) => {
if (typeof row.name !== "string" || row.name.length === 0) throw new Error(`SQLite table ${tableName} has an invalid column name`);
return row.name;
});
}
function readTableRowidModel(db, tableName, tableRow) {
if (Number(tableRow.wr ?? 0) === 1) return {
alias: null,
storage: "without-rowid"
};
const columns = readTableColumns$1(db, tableName);
const primaryKeyColumns = columns.filter((column) => Number(column.pk ?? 0) > 0);
const primaryKeyIndex = db.prepare(`SELECT 1 AS found FROM pragma_index_list(?) WHERE origin = 'pk' LIMIT 1`).get(tableName);
const primaryKeyType = primaryKeyColumns[0]?.type;
if (primaryKeyColumns.length === 1 && typeof primaryKeyType === "string" && primaryKeyType.toUpperCase() === "INTEGER" && !primaryKeyIndex) return {
alias: null,
storage: "integer-primary-key"
};
const declaredNames = new Set(columns.flatMap((column) => typeof column.name === "string" ? [column.name.toLowerCase()] : []));
const alias = SQLITE_ROWID_ALIASES.find((candidate) => !declaredNames.has(candidate)) ?? null;
if (!alias) throw new Error(`SQLite table ${tableName} shadows every rowid alias; its implicit rowids cannot be migrated safely`);
return {
alias,
storage: "implicit"
};
}
function readCanonicalStrictTables(schemaSql) {
const canonical = openNodeSqliteDatabase(":memory:");
try {
canonical.exec(schemaSql);
const tables = readMainTableList(canonical).filter((row) => row.type === "table");
const nonStrict = tables.filter((row) => Number(row.strict ?? 0) !== 1).map((row) => row.name);
if (nonStrict.length > 0) throw new Error(`Canonical SQLite schema contains non-STRICT tables: ${nonStrict.toSorted().join(", ")}`);
return tables.map((row) => {
const schemaRow = canonical.prepare("SELECT sql FROM sqlite_schema WHERE type = 'table' AND name = ?").get(row.name);
if (typeof schemaRow?.sql !== "string") throw new Error(`Canonical SQLite table ${row.name} has no CREATE statement`);
const rowidModel = readTableRowidModel(canonical, row.name, row);
return {
columns: readVisibleColumns(canonical, row.name),
createSql: schemaRow.sql,
name: row.name,
rowidAlias: rowidModel.alias,
rowidStorage: rowidModel.storage,
usesAutoincrement: /\bAUTOINCREMENT\b/iu.test(schemaRow.sql)
};
}).toSorted((left, right) => left.name.localeCompare(right.name));
} finally {
canonical.close();
}
}
function rewriteCreateTableName(createSql, replacementName) {
const openingParen = createSql.indexOf("(");
if (openingParen === -1) throw new Error("Canonical SQLite table CREATE statement has no column list");
return `CREATE TABLE ${quoteSqliteIdentifier(replacementName)} ${createSql.slice(openingParen)}`;
}
function readPreservedSchemaObjects(db, tableNames) {
return db.prepare("SELECT type, name, tbl_name, sql FROM sqlite_schema WHERE type IN ('index', 'trigger', 'view')").all().flatMap((row) => {
if (row.type !== "index" && row.type !== "trigger" && row.type !== "view" || typeof row.name !== "string" || typeof row.tbl_name !== "string" || typeof row.sql !== "string" || row.type === "index" && !tableNames.has(row.tbl_name)) return [];
return [{
name: row.name,
sql: row.sql,
type: row.type
}];
}).toSorted((left, right) => {
const typeOrder = {
view: 0,
index: 1,
trigger: 2
};
return typeOrder[left.type] - typeOrder[right.type] || left.name.localeCompare(right.name);
});
}
function readAutoincrementHighWater(db, tableName) {
if (!db.prepare("SELECT 1 AS found FROM sqlite_schema WHERE type = 'table' AND name = 'sqlite_sequence'").get()) return null;
const row = db.prepare("SELECT CAST(seq AS TEXT) AS seq FROM sqlite_sequence WHERE name = ?").get(tableName);
if (row === void 0) return null;
const normalized = typeof row.seq === "string" ? /^(\d+)(?:\.0+)?$/u.exec(row.seq)?.[1] : null;
if (!normalized) throw new Error(`SQLite table ${tableName} has an invalid AUTOINCREMENT high-water mark (${typeof row.seq}: ${String(row.seq)})`);
return normalized;
}
function restoreAutoincrementHighWater(db, tableName, previousHighWater) {
if (previousHighWater === null) return;
const currentHighWater = readAutoincrementHighWater(db, tableName);
const restored = currentHighWater === null || BigInt(previousHighWater) > BigInt(currentHighWater) ? previousHighWater : currentHighWater;
db.prepare("DELETE FROM sqlite_sequence WHERE name = ?").run(tableName);
db.prepare("INSERT INTO sqlite_sequence (name, seq) VALUES (?, CAST(? AS INTEGER))").run(tableName, restored);
}
function assertMatchingColumns(tableName, currentColumns, canonicalColumns) {
const current = new Set(currentColumns);
const canonical = new Set(canonicalColumns);
const missing = canonicalColumns.filter((column) => !current.has(column));
const extra = currentColumns.filter((column) => !canonical.has(column));
if (missing.length === 0 && extra.length === 0) return;
const details = [missing.length > 0 ? `missing ${missing.join(", ")}` : "", extra.length > 0 ? `extra ${extra.join(", ")}` : ""].filter(Boolean).join("; ");
throw new Error(`SQLite table ${tableName} does not match its canonical columns (${details})`);
}
function readForeignKeysEnabled(db) {
const row = db.prepare("PRAGMA foreign_keys").get();
return Number(row?.foreign_keys ?? 0) === 1;
}
/**
* Rebuild canonical non-STRICT tables inside the caller's transaction.
* Foreign-key enforcement must be disabled before BEGIN; integrity is checked
* before this function returns so any bad row or relationship rolls back.
*/
function migrateSqliteSchemaToStrictInTransaction(db, schemaSql, options = {}) {
if (!db.isTransaction) throw new Error("SQLite STRICT schema migration requires an active transaction");
const canonicalTables = readCanonicalStrictTables(schemaSql);
db.exec(schemaSql);
const currentTableRows = new Map(readMainTableList(db).filter((row) => row.type === "table").map((row) => [row.name, row]));
const tablesToMigrate = canonicalTables.filter((table) => Number(currentTableRows.get(table.name)?.strict ?? 0) !== 1);
if (tablesToMigrate.length === 0) return { migratedTables: [] };
if (readForeignKeysEnabled(db)) throw new Error("SQLite STRICT schema migration requires foreign_keys=OFF before BEGIN");
const preservedObjects = readPreservedSchemaObjects(db, new Set(tablesToMigrate.map((table) => table.name)));
for (const object of preservedObjects) if (object.type === "trigger") db.exec(`DROP TRIGGER ${quoteSqliteIdentifier(object.name)};`);
for (const object of preservedObjects) if (object.type === "view") db.exec(`DROP VIEW ${quoteSqliteIdentifier(object.name)};`);
for (const [index, table] of tablesToMigrate.entries()) {
const migrationTable = `${STRICT_MIGRATION_TABLE_PREFIX}${index}_${table.name}`;
if (currentTableRows.has(migrationTable)) throw new Error(`SQLite STRICT migration table already exists: ${migrationTable}`);
const currentColumns = readVisibleColumns(db, table.name);
assertMatchingColumns(table.name, currentColumns, table.columns);
const currentTableRow = currentTableRows.get(table.name);
if (!currentTableRow) throw new Error(`SQLite table ${table.name} disappeared during STRICT migration`);
const currentRowidModel = readTableRowidModel(db, table.name, currentTableRow);
if (currentRowidModel.storage !== table.rowidStorage) throw new Error(`SQLite table ${table.name} changes rowid storage from ${currentRowidModel.storage} to ${table.rowidStorage}; refusing an identity-changing STRICT migration`);
const previousHighWater = table.usesAutoincrement ? readAutoincrementHighWater(db, table.name) : null;
db.exec(rewriteCreateTableName(table.createSql, migrationTable));
const columns = table.columns.map(quoteSqliteIdentifier);
if (table.rowidAlias) columns.unshift(quoteSqliteIdentifier(table.rowidAlias));
const copyColumns = columns.join(", ");
try {
db.exec(`INSERT INTO ${quoteSqliteIdentifier(migrationTable)} (${copyColumns}) SELECT ${copyColumns} FROM ${quoteSqliteIdentifier(table.name)};`);
} catch (error) {
throw new Error(`Failed migrating SQLite table ${table.name} to STRICT`, { cause: error });
}
db.exec(`DROP TABLE ${quoteSqliteIdentifier(table.name)};`);
db.exec(`ALTER TABLE ${quoteSqliteIdentifier(migrationTable)} RENAME TO ${quoteSqliteIdentifier(table.name)};`);
restoreAutoincrementHighWater(db, table.name, previousHighWater);
}
db.exec(schemaSql);
const findObject = db.prepare("SELECT 1 AS found FROM sqlite_schema WHERE type = ? AND name = ? LIMIT 1");
for (const object of preservedObjects) if (!findObject.get(object.type, object.name)) db.exec(object.sql);
assertSqliteIntegrity(db, options.databaseLabel ?? "SQLite STRICT schema migration");
return { migratedTables: tablesToMigrate.map((table) => table.name) };
}
/** Atomically upgrade OpenClaw-owned tables described by a canonical STRICT schema. */
function migrateSqliteSchemaToStrict(db, schemaSql, options = {}) {
if (db.isTransaction) throw new Error("SQLite STRICT schema migration cannot start inside a transaction");
const foreignKeysWereEnabled = readForeignKeysEnabled(db);
if (foreignKeysWereEnabled) db.exec("PRAGMA foreign_keys = OFF;");
try {
return runSqliteImmediateTransactionSync(db, () => migrateSqliteSchemaToStrictInTransaction(db, schemaSql, options), {
busyTimeoutMs: options.busyTimeoutMs ?? DEFAULT_STRICT_MIGRATION_BUSY_TIMEOUT_MS,
databaseLabel: options.databaseLabel,
operationLabel: "sqlite.strict-schema-migration"
});
} finally {
if (foreignKeysWereEnabled) db.exec("PRAGMA foreign_keys = ON;");
}
}
[
"insert",
"update",
"delete"
].map((event) => ({
name: `memory_index_chunks_revision_after_${event}`,
sql: `CREATE TRIGGER IF NOT EXISTS memory_index_chunks_revision_after_${event}
AFTER ${event.toUpperCase()} ON memory_index_chunks
BEGIN UPDATE memory_index_state SET revision = revision + 1 WHERE id = 1; END;`
}));
//#endregion
//#region src/state/openclaw-agent-schema.ts
const OPENCLAW_AGENT_SCHEMA_SQL = "-- Session storage doctrine: session_nodes.entry_json owns hot logical-session facts;\n-- session_entry_snapshots owns keyed cold values. Promoted node columns are query\n-- indexes; session_windows and their children own transcript generations.\n-- Legacy ACP provenance is private import evidence carried with its logical session.\n\nCREATE TABLE IF NOT EXISTS schema_meta (\n meta_key TEXT NOT NULL PRIMARY KEY,\n role TEXT NOT NULL,\n schema_version INTEGER NOT NULL,\n agent_id TEXT,\n app_version TEXT,\n created_at INTEGER NOT NULL,\n updated_at INTEGER NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS session_nodes (\n session_key TEXT NOT NULL PRIMARY KEY,\n current_session_id TEXT NOT NULL,\n entry_json TEXT NOT NULL,\n snapshot_revision INTEGER NOT NULL DEFAULT 0,\n legacy_acp_migration_json TEXT,\n entry_valid INTEGER NOT NULL DEFAULT 0 CHECK (entry_valid IN (-1, 0, 1)),\n updated_at INTEGER NOT NULL,\n status TEXT CHECK (status IS NULL OR status IN ('running', 'done', 'failed', 'killed', 'timeout')),\n created_at INTEGER,\n created_via TEXT CHECK (created_via IS NULL OR created_via IN ('operator', 'spawn', 'channel', 'cron', 'talk', 'run', 'plugin', 'internal')),\n created_actor_type TEXT CHECK (created_actor_type IS NULL OR created_actor_type IN ('human', 'agent', 'system')),\n created_actor_id TEXT,\n owner_actor_type TEXT,\n owner_actor_id TEXT,\n owner_assigned_by_type TEXT,\n owner_assigned_by_id TEXT,\n owner_assigned_at INTEGER,\n project_id TEXT,\n parent_session_key TEXT,\n spawned_by TEXT,\n fork_source_session_key TEXT,\n fork_source_session_id TEXT,\n fork_source_entry_id TEXT,\n label TEXT,\n display_name TEXT,\n category TEXT,\n icon TEXT,\n pinned_at INTEGER,\n archived_at INTEGER,\n last_read_at INTEGER,\n last_interaction_at INTEGER,\n last_activity_at INTEGER\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS session_entry_snapshots (\n session_key TEXT NOT NULL,\n field TEXT NOT NULL CHECK (field IN ('sessionDiffBaseline', 'skillsSnapshot', 'systemPromptReport')),\n value_json TEXT NOT NULL,\n PRIMARY KEY (session_key, field),\n FOREIGN KEY (session_key) REFERENCES session_nodes(session_key) ON DELETE CASCADE\n) STRICT, WITHOUT ROWID;\n\nCREATE TRIGGER IF NOT EXISTS session_entry_snapshots_after_insert\nAFTER INSERT ON session_entry_snapshots\nBEGIN\n UPDATE session_nodes SET snapshot_revision = snapshot_revision + 1\n WHERE session_key = NEW.session_key;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS session_entry_snapshots_after_update\nAFTER UPDATE OF session_key, field, value_json ON session_entry_snapshots\nWHEN NEW.session_key IS NOT OLD.session_key\n OR NEW.field IS NOT OLD.field OR NEW.value_json IS NOT OLD.value_json\nBEGIN\n UPDATE session_nodes SET snapshot_revision = snapshot_revision + 1\n WHERE session_key IN (OLD.session_key, NEW.session_key);\nEND;\n\nCREATE TRIGGER IF NOT EXISTS session_entry_snapshots_after_delete\nAFTER DELETE ON session_entry_snapshots\nBEGIN\n UPDATE session_nodes SET snapshot_revision = snapshot_revision + 1\n WHERE session_key = OLD.session_key;\nEND;\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_nodes_updated_at\n ON session_nodes(updated_at DESC, session_key);\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_nodes_last_interaction_at\n ON session_nodes(last_interaction_at DESC, session_key);\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_nodes_label\n ON session_nodes(label, session_key)\n WHERE label IS NOT NULL;\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_nodes_parent_session_key\n ON session_nodes(parent_session_key, session_key);\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_nodes_spawned_by\n ON session_nodes(spawned_by, session_key);\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_nodes_status\n ON session_nodes(status, session_key)\n WHERE status IS NOT NULL;\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_nodes_archived_at\n ON session_nodes(archived_at, session_key)\n WHERE archived_at IS NOT NULL;\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_nodes_active\n ON session_nodes(session_key)\n WHERE archived_at IS NULL;\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_nodes_current_session_id\n ON session_nodes(current_session_id);\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_nodes_entry_valid_pending\n ON session_nodes(session_key)\n WHERE entry_valid = 0;\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_nodes_entry_not_valid\n ON session_nodes(session_key)\n WHERE entry_valid != 1;\n\nCREATE TABLE IF NOT EXISTS session_participants (\n session_key TEXT NOT NULL,\n identity_namespace TEXT NOT NULL,\n actor_id TEXT NOT NULL,\n contribution_count INTEGER NOT NULL,\n first_prompted_at INTEGER,\n last_prompted_at INTEGER,\n PRIMARY KEY (session_key, identity_namespace, actor_id),\n FOREIGN KEY (session_key) REFERENCES session_nodes(session_key) ON DELETE CASCADE\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS session_key_contract (\n id INTEGER NOT NULL PRIMARY KEY CHECK (id = 1),\n main_key TEXT NOT NULL,\n canonical_ready TEXT,\n updated_at INTEGER NOT NULL\n) STRICT;\n\nINSERT OR IGNORE INTO session_key_contract (id, main_key, updated_at) VALUES (1, 'main', 0);\n\nCREATE TRIGGER IF NOT EXISTS session_nodes_entry_valid_after_insert\nAFTER INSERT ON session_nodes\nBEGIN\n UPDATE session_nodes SET entry_valid = 0 WHERE session_key = NEW.session_key;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS session_nodes_entry_valid_after_entry_update\nAFTER UPDATE OF entry_json ON session_nodes\nBEGIN\n UPDATE session_nodes SET entry_valid = 0 WHERE session_key = NEW.session_key;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS session_nodes_entry_valid_after_identity_update\nAFTER UPDATE OF current_session_id, updated_at ON session_nodes\nBEGIN\n UPDATE session_nodes SET entry_valid = 0 WHERE session_key = NEW.session_key;\nEND;\n\nCREATE TABLE IF NOT EXISTS session_windows (\n session_id TEXT NOT NULL PRIMARY KEY,\n session_key TEXT NOT NULL,\n previous_session_id TEXT,\n reason TEXT CHECK (reason IS NULL OR reason IN ('initial', 'reset', 'rollover', 'fork', 'rewind', 'switch', 'recovery', 'compaction')),\n session_scope TEXT NOT NULL DEFAULT 'conversation' CHECK (session_scope IN ('conversation', 'shared-main', 'group', 'channel')),\n created_at INTEGER NOT NULL,\n updated_at INTEGER NOT NULL,\n transcript_updated_at INTEGER DEFAULT NULL,\n transcript_observed_at INTEGER DEFAULT NULL,\n session_entry_provenance INTEGER NOT NULL DEFAULT 0 CHECK (session_entry_provenance IN (0, 1)),\n acp_owned INTEGER NOT NULL DEFAULT 0 CHECK (acp_owned IN (0, 1)),\n plugin_owner_id TEXT,\n hook_external_content_source TEXT CHECK (hook_external_content_source IS NULL OR hook_external_content_source IN ('gmail', 'webhook')),\n started_at INTEGER,\n ended_at INTEGER,\n status TEXT CHECK (status IS NULL OR status IN ('running', 'done', 'failed', 'killed', 'timeout')),\n chat_type TEXT CHECK (chat_type IS NULL OR chat_type IN ('direct', 'group', 'channel')),\n channel TEXT,\n account_id TEXT,\n primary_conversation_id TEXT,\n model_provider TEXT,\n model TEXT,\n agent_harness_id TEXT,\n parent_session_key TEXT,\n spawned_by TEXT,\n display_name TEXT,\n FOREIGN KEY (session_key) REFERENCES session_nodes(session_key) ON DELETE CASCADE,\n FOREIGN KEY (primary_conversation_id) REFERENCES conversations(conversation_id) ON DELETE SET NULL\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_windows_updated_at\n ON session_windows(updated_at DESC, session_id);\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_windows_session_key\n ON session_windows(session_key, updated_at DESC, session_id);\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_windows_created_at\n ON session_windows(created_at DESC, session_id);\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_windows_conversation\n ON session_windows(primary_conversation_id, updated_at DESC, session_id)\n WHERE primary_conversation_id IS NOT NULL;\n\n-- No foreign key: node triggers settle key renames and deletion even while a\n-- maintenance owner has disabled foreign-key enforcement.\nCREATE TABLE IF NOT EXISTS session_canonical_validation_pending (\n session_key TEXT NOT NULL PRIMARY KEY\n) STRICT;\n\n-- Avoid trigger-local conflict clauses: SQLite inherits the outer writer's\n-- conflict policy, including writers that predate this validation projection.\nCREATE TRIGGER IF NOT EXISTS session_nodes_canonical_pending_after_insert\nAFTER INSERT ON session_nodes\nBEGIN\n INSERT INTO session_canonical_validation_pending (session_key)\n SELECT NEW.session_key\n WHERE NOT EXISTS (\n SELECT 1 FROM session_canonical_validation_pending WHERE session_key = NEW.session_key\n );\nEND;\n\nCREATE TRIGGER IF NOT EXISTS session_nodes_canonical_pending_after_update\nAFTER UPDATE OF session_key, current_session_id, entry_json, entry_valid,\n parent_session_key, spawned_by, fork_source_session_key ON session_nodes\nWHEN OLD.session_key IS NOT NEW.session_key\n OR OLD.current_session_id IS NOT NEW.current_session_id\n OR OLD.entry_json IS NOT NEW.entry_json\n OR OLD.entry_valid IS NOT NEW.entry_valid\n OR OLD.parent_session_key IS NOT NEW.parent_session_key\n OR OLD.spawned_by IS NOT NEW.spawned_by\n OR OLD.fork_source_session_key IS NOT NEW.fork_source_session_key\nBEGIN\n DELETE FROM session_canonical_validation_pending\n WHERE session_key = OLD.session_key AND OLD.session_key IS NOT NEW.session_key;\n INSERT INTO session_canonical_validation_pending (session_key)\n SELECT NEW.session_key\n WHERE NOT EXISTS (\n SELECT 1 FROM session_canonical_validation_pending WHERE session_key = NEW.session_key\n );\nEND;\n\nCREATE TRIGGER IF NOT EXISTS session_nodes_canonical_pending_after_delete\nAFTER DELETE ON session_nodes\nBEGIN\n DELETE FROM session_canonical_validation_pending WHERE session_key = OLD.session_key;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS session_windows_canonical_pending_after_insert\nAFTER INSERT ON session_windows\nBEGIN\n INSERT INTO session_canonical_validation_pending (session_key)\n SELECT node.session_key FROM session_nodes AS node\n WHERE node.current_session_id = NEW.session_id\n AND NOT EXISTS (\n SELECT 1 FROM session_canonical_validation_pending AS pending\n WHERE pending.session_key = node.session_key\n );\nEND;\n\nCREATE TRIGGER IF NOT EXISTS session_windows_canonical_pending_after_update\nAFTER UPDATE OF session_id, session_key ON session_windows\nWHEN OLD.session_id IS NOT NEW.session_id OR OLD.session_key IS NOT NEW.session_key\nBEGIN\n INSERT INTO session_canonical_validation_pending (session_key)\n SELECT node.session_key FROM session_nodes AS node\n WHERE node.current_session_id IN (OLD.session_id, NEW.session_id)\n AND NOT EXISTS (\n SELECT 1 FROM session_canonical_validation_pending AS pending\n WHERE pending.session_key = node.session_key\n );\nEND;\n\nCREATE TRIGGER IF NOT EXISTS session_windows_canonical_pending_after_delete\nAFTER DELETE ON session_windows\nBEGIN\n INSERT INTO session_canonical_validation_pending (session_key)\n SELECT node.session_key FROM session_nodes AS node\n WHERE node.current_session_id = OLD.session_id\n AND NOT EXISTS (\n SELECT 1 FROM session_canonical_validation_pending AS pending\n WHERE pending.session_key = node.session_key\n );\nEND;\n\nCREATE TRIGGER IF NOT EXISTS session_key_contract_canonical_pending_after_insert\nAFTER INSERT ON session_key_contract\nBEGIN\n INSERT INTO session_canonical_validation_pending (session_key)\n SELECT node.session_key FROM session_nodes AS node\n WHERE NOT EXISTS (\n SELECT 1 FROM session_canonical_validation_pending AS pending\n WHERE pending.session_key = node.session_key\n );\nEND;\n\nCREATE TRIGGER IF NOT EXISTS session_key_contract_canonical_pending_after_update\nAFTER UPDATE OF main_key ON session_key_contract\nWHEN OLD.main_key IS NOT NEW.main_key\nBEGIN\n INSERT INTO session_canonical_validation_pending (session_key)\n SELECT node.session_key FROM session_nodes AS node\n WHERE NOT EXISTS (\n SELECT 1 FROM session_canonical_validation_pending AS pending\n WHERE pending.session_key = node.session_key\n );\nEND;\n\nCREATE TRIGGER IF NOT EXISTS session_key_contract_canonical_pending_after_delete\nAFTER DELETE ON session_key_contract\nBEGIN\n INSERT INTO session_canonical_validation_pending (session_key)\n SELECT node.session_key FROM session_nodes AS node\n WHERE NOT EXISTS (\n SELECT 1 FROM session_canonical_validation_pending AS pending\n WHERE pending.session_key = node.session_key\n );\nEND;\n\nCREATE TABLE IF NOT EXISTS conversations (\n conversation_id TEXT NOT NULL PRIMARY KEY,\n channel TEXT NOT NULL,\n account_id TEXT NOT NULL,\n kind TEXT NOT NULL CHECK (kind IN ('direct', 'group', 'channel')),\n peer_id TEXT NOT NULL,\n delivery_target TEXT NOT NULL,\n parent_conversation_id TEXT,\n thread_id TEXT,\n native_channel_id TEXT,\n native_direct_user_id TEXT,\n label TEXT,\n metadata_json TEXT,\n created_at INTEGER NOT NULL,\n updated_at INTEGER NOT NULL\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_agent_conversations_lookup\n ON conversations(channel, account_id, kind, peer_id, thread_id);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_agent_conversations_identity\n ON conversations(\n channel,\n account_id,\n kind,\n peer_id,\n IFNULL(parent_conversation_id, ''),\n IFNULL(thread_id, '')\n );\n\nCREATE INDEX IF NOT EXISTS idx_agent_conversations_updated\n ON conversations(updated_at DESC, conversation_id);\n\nCREATE TABLE IF NOT EXISTS conversation_deliveries (\n operation_id TEXT NOT NULL PRIMARY KEY,\n operation_kind TEXT NOT NULL CHECK (operation_kind IN ('send', 'turn')),\n conversation_id TEXT NOT NULL,\n source_session_key TEXT,\n message_hash TEXT NOT NULL,\n status TEXT NOT NULL CHECK (status IN ('created', 'queued', 'sent', 'suppressed', 'rejected', 'unknown', 'replied')),\n prepared_message_id TEXT,\n platform_message_id TEXT,\n queue_id TEXT,\n rejection_error TEXT,\n reply_message_id TEXT,\n reply_to_id TEXT,\n reply_thread_id TEXT,\n reply_text TEXT,\n reply_timestamp INTEGER,\n created_at INTEGER NOT NULL,\n updated_at INTEGER NOT NULL,\n CHECK (\n (status = 'rejected' AND rejection_error IS NOT NULL) OR\n (status != 'rejected' AND rejection_error IS NULL)\n ),\n FOREIGN KEY (conversation_id) REFERENCES conversations(conversation_id) ON DELETE CASCADE\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_agent_conversation_deliveries_reply\n ON conversation_deliveries(conversation_id, platform_message_id, prepared_message_id)\n WHERE status IN ('queued', 'sent', 'replied');\n\nCREATE INDEX IF NOT EXISTS idx_agent_conversation_deliveries_updated\n ON conversation_deliveries(updated_at DESC, operation_id);\n\nCREATE TABLE IF NOT EXISTS session_conversations (\n session_id TEXT NOT NULL,\n conversation_id TEXT NOT NULL,\n role TEXT NOT NULL DEFAULT 'primary' CHECK (role IN ('primary', 'participant', 'related')),\n route_context_json TEXT,\n first_seen_at INTEGER NOT NULL,\n last_seen_at INTEGER NOT NULL,\n PRIMARY KEY (session_id, conversation_id, role),\n FOREIGN KEY (session_id) REFERENCES \"session_windows\"(session_id) ON DELETE CASCADE,\n FOREIGN KEY (conversation_id) REFERENCES conversations(conversation_id) ON DELETE CASCADE\n) STRICT;\n\n-- Older same-version writers preserve the envelope while updating the association.\nCREATE TRIGGER IF NOT EXISTS session_conversations_route_context_invalidate_after_update\nAFTER UPDATE OF role, last_seen_at ON session_conversations\nWHEN NEW.route_context_json IS OLD.route_context_json\nBEGIN\n UPDATE session_conversations\n SET route_context_json = NULL\n WHERE session_id = NEW.session_id\n AND conversation_id = NEW.conversation_id\n AND role = NEW.role;\nEND;\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_conversations_conversation\n ON session_conversations(conversation_id, last_seen_at DESC, session_id);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_agent_session_conversations_primary\n ON session_conversations(session_id)\n WHERE role = 'primary';\n\nCREATE TABLE IF NOT EXISTS session_members (\n session_key TEXT NOT NULL,\n identity_id TEXT NOT NULL,\n added_by TEXT NOT NULL,\n added_at INTEGER NOT NULL,\n PRIMARY KEY (session_key, identity_id),\n FOREIGN KEY (session_key) REFERENCES session_nodes(session_key) ON DELETE CASCADE\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_members_identity\n ON session_members(identity_id, session_key);\n\nCREATE TABLE IF NOT EXISTS session_suggestions (\n id TEXT PRIMARY KEY,\n session_key TEXT NOT NULL,\n author_id TEXT NOT NULL,\n author_label TEXT,\n text TEXT NOT NULL,\n created_at INTEGER NOT NULL,\n state TEXT NOT NULL CHECK (state IN ('pending', 'accepted', 'dismissed')),\n dispatch_token TEXT,\n dispatch_started_at INTEGER,\n dispatch_resolution TEXT CHECK (dispatch_resolution IN ('send', 'queue', 'edit', 'dismiss')),\n CHECK (\n (dispatch_token IS NULL AND dispatch_started_at IS NULL AND dispatch_resolution IS NULL)\n OR (dispatch_token IS NOT NULL AND dispatch_started_at IS NOT NULL AND dispatch_resolution IS NOT NULL)\n ),\n FOREIGN KEY (session_key) REFERENCES session_nodes(session_key) ON DELETE CASCADE\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_suggestions_session_state_created\n ON session_suggestions(session_key, state, created_at, id);\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_suggestions_author_created\n ON session_suggestions(author_id, created_at, id);\n\nCREATE TABLE IF NOT EXISTS board_tabs (\n session_key TEXT NOT NULL,\n tab_id TEXT NOT NULL,\n title TEXT NOT NULL,\n position INTEGER NOT NULL CHECK (position >= 0),\n chat_dock TEXT NOT NULL DEFAULT 'right' CHECK (chat_dock IN ('left', 'right', 'bottom', 'hidden')),\n created_by TEXT NOT NULL CHECK (created_by IN ('user', 'agent')),\n revision INTEGER NOT NULL CHECK (revision >= 0),\n PRIMARY KEY (session_key, tab_id),\n FOREIGN KEY (session_key) REFERENCES session_nodes(session_key) ON DELETE CASCADE\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS board_widgets (\n session_key TEXT NOT NULL,\n name TEXT NOT NULL,\n tab_id TEXT NOT NULL,\n title TEXT,\n content_kind TEXT NOT NULL CHECK (content_kind IN ('html', 'mcp-app', 'plugin')),\n html BLOB,\n descriptor_json TEXT,\n sha256 TEXT NOT NULL,\n view_generation TEXT,\n revision INTEGER NOT NULL CHECK (revision >= 1),\n size_w INTEGER NOT NULL CHECK (size_w BETWEEN 1 AND 12),\n size_h INTEGER NOT NULL CHECK (size_h BETWEEN 1 AND 20),\n position INTEGER NOT NULL CHECK (position >= 0),\n manifest TEXT NOT NULL DEFAULT '{}',\n grant_state TEXT NOT NULL DEFAULT 'none' CHECK (grant_state IN ('none', 'pending', 'granted', 'rejected')),\n granted_sha TEXT,\n created_by TEXT NOT NULL CHECK (created_by IN ('user', 'agent')),\n created_at INTEGER NOT NULL,\n updated_at INTEGER NOT NULL,\n PRIMARY KEY (session_key, name),\n FOREIGN KEY (session_key, tab_id) REFERENCES board_tabs(session_key, tab_id) ON DELETE CASCADE,\n CHECK (\n (content_kind = 'html' AND html IS NOT NULL AND descriptor_json IS NULL AND view_generation IS NOT NULL) OR\n (content_kind = 'mcp-app' AND html IS NULL AND descriptor_json IS NOT NULL AND view_generation IS NULL) OR\n (content_kind = 'plugin' AND html IS NULL AND descriptor_json IS NOT NULL AND view_generation IS NULL)\n )\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_agent_board_widgets_tab_position\n ON board_widgets(session_key, tab_id, position);\n\nCREATE TABLE IF NOT EXISTS session_progress_cards (\n session_key TEXT NOT NULL PRIMARY KEY,\n markdown TEXT,\n steps_json TEXT,\n revision INTEGER NOT NULL,\n created_at INTEGER NOT NULL,\n updated_at INTEGER NOT NULL,\n FOREIGN KEY (session_key) REFERENCES session_nodes(session_key) ON DELETE CASCADE\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS heartbeat_outcomes (\n session_key TEXT NOT NULL PRIMARY KEY,\n run_session_key TEXT NOT NULL,\n outcome TEXT NOT NULL CHECK (outcome IN ('progress', 'done', 'blocked', 'needs_attention')),\n summary TEXT NOT NULL,\n response_reason TEXT,\n priority TEXT CHECK (priority IS NULL OR priority IN ('low', 'normal', 'high')),\n next_check TEXT,\n task_names_json TEXT,\n wake_source TEXT,\n wake_reason TEXT,\n occurred_at INTEGER NOT NULL,\n context_run_id TEXT,\n context_claimed_at INTEGER,\n updated_at INTEGER NOT NULL,\n FOREIGN KEY (session_key) REFERENCES session_nodes(session_key) ON DELETE CASCADE\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS message_tool_run_outcomes (\n id INTEGER PRIMARY KEY,\n run_id TEXT NOT NULL,\n session_key TEXT NOT NULL,\n agent_id TEXT NOT NULL,\n provider TEXT NOT NULL,\n model TEXT NOT NULL,\n outcome TEXT NOT NULL CHECK (outcome IN ('tool_delivered', 'mute')),\n run_status TEXT NOT NULL CHECK (run_status IN ('completed', 'errored', 'aborted')),\n occurred_at INTEGER NOT NULL\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_agent_message_tool_run_outcomes_occurred\n ON message_tool_run_outcomes(occurred_at DESC, id DESC);\n\n-- Receipts outlive Goal clear and session reset so a delayed retry cannot recreate a Goal.\n-- They intentionally have no session FK; bounded retention belongs to the operation owner.\nCREATE TABLE IF NOT EXISTS session_goal_operations (\n session_key TEXT NOT NULL,\n operation_id TEXT NOT NULL,\n session_id TEXT NOT NULL,\n request_fingerprint TEXT NOT NULL,\n result_json TEXT NOT NULL,\n expires_at INTEGER NOT NULL,\n PRIMARY KEY (session_key, operation_id)\n) STRICT;\nCREATE INDEX IF NOT EXISTS idx_agent_session_goal_operations_expiry\n ON session_goal_operations(expires_at);\n\nCREATE TABLE IF NOT EXISTS transcript_events (\n session_id TEXT NOT NULL,\n seq INTEGER NOT NULL,\n event_json TEXT,\n created_at INTEGER NOT NULL,\n event_zstd BLOB,\n event_utf8_bytes INTEGER CHECK (event_utf8_bytes IS NULL OR event_utf8_bytes >= 0),\n navigation_json TEXT,\n PRIMARY KEY (session_id, seq),\n FOREIGN KEY (session_id) REFERENCES \"session_windows\"(session_id) ON DELETE CASCADE,\n CHECK (\n (event_json IS NOT NULL AND event_zstd IS NULL)\n OR (\n event_json IS NULL AND event_zstd IS NOT NULL\n AND event_utf8_bytes IS NOT NULL\n AND event_utf8_bytes BETWEEN 1 AND 4194304\n AND length(event_zstd) BETWEEN 1 AND 4194304\n AND navigation_json IS NOT NULL\n )\n ),\n CHECK (\n navigation_json IS NULL OR CASE WHEN json_valid(navigation_json) THEN coalesce(\n octet_length(navigation_json) <= 16384\n AND json_type(navigation_json, '$.version') = 'integer'\n AND json_extract(navigation_json, '$.version') = 1\n AND json_type(navigation_json, '$.report') = 'object'\n AND json_extract(navigation_json, '$.report.kind') IN ('canonical', 'leaf', 'link', 'ignored')\n AND json_type(navigation_json, '$.navigation') = 'object'\n AND json_type(navigation_json, '$.reset') = 'object'\n AND json_type(navigation_json, '$.model') = 'object'\n AND json_type(navigation_json, '$.modelBytes') = 'integer'\n AND json_extract(navigation_json, '$.modelBytes') BETWEEN 0 AND 4194304\n AND json_type(navigation_json, '$.modelWithoutCheckpointBytes') = 'integer'\n AND json_extract(navigation_json, '$.modelWithoutCheckpointBytes') BETWEEN 0 AND 4194304\n AND json_type(navigation_json, '$.withoutCustomDataBytes') = 'integer'\n AND json_extract(navigation_json, '$.withoutCustomDataBytes') BETWEEN 0 AND 4194304,\n 0) ELSE 0 END\n )\n) STRICT;\n\n-- Canonical cold-tier owner for reclaimed transcript generations. The derived\n-- .deleted/.reset file may be recreated from this row after a crash.\nCREATE TABLE IF NOT EXISTS session_transcript_archives (\n session_id TEXT NOT NULL,\n generation TEXT NOT NULL,\n session_key TEXT NOT NULL,\n reason TEXT NOT NULL CHECK (reason IN ('deleted', 'reset')),\n encoding TEXT NOT NULL CHECK (encoding IN ('identity', 'zstd')),\n archive_blob BLOB NOT NULL,\n archive_sha256 TEXT NOT NULL CHECK (length(archive_sha256) = 64),\n archive_name TEXT NOT NULL UNIQUE,\n created_at INTEGER NOT NULL,\n published_at INTEGER,\n publish_attempts INTEGER NOT NULL DEFAULT 0 CHECK (publish_attempts >= 0),\n last_publish_attempt_at INTEGER,\n last_publish_error TEXT,\n PRIMARY KEY (session_id, generation),\n CHECK (archive_name NOT LIKE '%/%' AND archive_name NOT LIKE '%\\%')\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_transcript_archives_pending\n ON session_transcript_archives(created_at, session_id, generation)\n WHERE published_at IS NULL;\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_transcript_archives_retention\n ON session_transcript_archives(created_at, session_id, generation);\n\nCREATE TABLE IF NOT EXISTS session_transcript_cold_archives (\n session_id TEXT NOT NULL PRIMARY KEY,\n generation TEXT NOT NULL,\n archive_name TEXT NOT NULL UNIQUE,\n archive_sha256 TEXT NOT NULL CHECK (length(archive_sha256) = 64),\n event_count INTEGER NOT NULL CHECK (event_count >= 1),\n raw_bytes INTEGER NOT NULL CHECK (raw_bytes >= 0),\n archive_bytes INTEGER NOT NULL CHECK (archive_bytes >= 0),\n last_seq INTEGER NOT NULL,\n archived_at INTEGER NOT NULL,\n storage TEXT NOT NULL CHECK (storage IN ('file', 'sqlite')),\n archive_blob BLOB,\n FOREIGN KEY (session_id) REFERENCES \"session_windows\"(session_id) ON DELETE CASCADE,\n CHECK (length(archive_name) > 0 AND archive_name NOT IN ('.', '..') AND archive_name NOT LIKE '%/%' AND archive_name NOT LIKE '%\\%'),\n CHECK ((storage = 'file' AND archive_blob IS NULL) OR (storage = 'sqlite' AND archive_blob IS NOT NULL))\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS transcript_rewrite_watermarks (\n session_id TEXT NOT NULL PRIMARY KEY,\n generation TEXT NOT NULL,\n updated_at INTEGER NOT NULL,\n FOREIGN KEY (session_id) REFERENCES \"session_windows\"(session_id) ON DELETE CASCADE\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS trajectory_runtime_events (\n session_id TEXT NOT NULL,\n seq INTEGER NOT NULL,\n run_id TEXT,\n event_json TEXT NOT NULL,\n created_at INTEGER NOT NULL,\n PRIMARY KEY (session_id, seq),\n FOREIGN KEY (session_id) REFERENCES \"session_windows\"(session_id) ON DELETE CASCADE\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_agent_trajectory_runtime_run\n ON trajectory_runtime_events(session_id, run_id, seq)\n WHERE run_id IS NOT NULL;\n\nCREATE TABLE IF NOT EXISTS acp_parent_stream_events (\n session_id TEXT NOT NULL,\n run_id TEXT NOT NULL,\n seq INTEGER NOT NULL,\n event_json TEXT NOT NULL,\n created_at INTEGER NOT NULL,\n PRIMARY KEY (session_id, run_id, seq),\n FOREIGN KEY (session_id) REFERENCES \"session_windows\"(session_id) ON DELETE CASCADE\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_agent_acp_parent_stream_run\n ON acp_parent_stream_events(run_id, seq);\n\nCREATE TABLE IF NOT EXISTS transcript_event_identities (\n session_id TEXT NOT NULL,\n event_id TEXT NOT NULL,\n seq INTEGER NOT NULL,\n event_type TEXT,\n parent_id TEXT,\n message_idempotency_key TEXT,\n created_at INTEGER NOT NULL,\n PRIMARY KEY (session_id, event_id),\n FOREIGN KEY (session_id, seq) REFERENCES transcript_events(session_id, seq) ON DELETE CASCADE\n) STRICT;\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_agent_transcript_message_idempotency\n ON transcript_event_identities(session_id, message_idempotency_key)\n WHERE message_idempotency_key IS NOT NULL;\n\nCREATE INDEX IF NOT EXISTS idx_agent_transcript_event_identity_sequence\n ON transcript_event_identities(session_id, seq);\n\nCREATE INDEX IF NOT EXISTS idx_agent_transcript_event_parent\n ON transcript_event_identities(session_id, parent_id)\n WHERE parent_id IS NOT NULL;\n\nCREATE INDEX IF NOT EXISTS idx_agent_transcript_event_sequence\n ON transcript_event_identities(session_id, event_type, seq DESC);\n\nCREATE TABLE IF NOT EXISTS context_engine_turn_outbox (\n advancement_key TEXT NOT NULL PRIMARY KEY,\n engine_id TEXT NOT NULL,\n owner_plugin_id TEXT,\n session_id TEXT NOT NULL,\n payload_json TEXT NOT NULL,\n attempt_count INTEGER NOT NULL DEFAULT 0,\n last_attempt_at INTEGER,\n last_error TEXT,\n created_at INTEGER NOT NULL\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_agent_context_engine_turn_outbox_engine\n ON context_engine_turn_outbox(engine_id, created_at);\n\nCREATE TABLE IF NOT EXISTS cache_entries (\n scope TEXT NOT NULL,\n key TEXT NOT NULL,\n value_json TEXT,\n blob BLOB,\n expires_at INTEGER,\n updated_at INTEGER NOT NULL,\n PRIMARY KEY (scope, key)\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_agent_cache_expiry\n ON cache_entries(scope, expires_at, key)\n WHERE expires_at IS NOT NULL;\n\nCREATE INDEX IF NOT EXISTS idx_agent_cache_updated\n ON cache_entries(scope, updated_at DESC, key);\n\nCREATE TABLE IF NOT EXISTS auth_profile_store (\n store_key TEXT NOT NULL PRIMARY KEY,\n store_json TEXT NOT NULL,\n updated_at INTEGER NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS auth_profile_state (\n state_key TEXT NOT NULL PRIMARY KEY,\n state_json TEXT NOT NULL,\n updated_at INTEGER NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS memory_index_meta (\n key TEXT PRIMARY KEY,\n value TEXT NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS memory_index_sources (\n id INTEGER PRIMARY KEY,\n path TEXT NOT NULL,\n source TEXT NOT NULL DEFAULT 'memory',\n hash TEXT NOT NULL,\n mtime REAL NOT NULL,\n size INTEGER NOT NULL,\n UNIQUE (path, source)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS memory_index_chunks (\n chunk_rowid INTEGER PRIMARY KEY,\n id TEXT NOT NULL UNIQUE,\n path TEXT NOT NULL,\n source TEXT NOT NULL DEFAULT 'memory',\n start_line INTEGER NOT NULL,\n end_line INTEGER NOT NULL,\n hash TEXT NOT NULL,\n model TEXT NOT NULL,\n text TEXT NOT NULL,\n embedding BLOB NOT NULL,\n updated_at INTEGER NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS memory_index_chunk_recall_metadata (\n chunk_id TEXT PRIMARY KEY,\n importance INTEGER CHECK (importance IS NULL OR importance BETWEEN 1 AND 10),\n triggers TEXT,\n project_key TEXT,\n FOREIGN KEY (chunk_id) REFERENCES memory_index_chunks(id) ON DELETE CASCADE\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS memory_index_chunk_provenance (\n chunk_id TEXT PRIMARY KEY,\n origin_class TEXT NOT NULL CHECK (origin_class IN ('owner', 'agent', 'untrusted', 'system')),\n session_kind TEXT NOT NULL CHECK (session_kind IN ('interactive', 'cron', 'heartbeat', 'subagent', 'unknown')),\n observed_at INTEGER NOT NULL,\n supersedes_key TEXT,\n FOREIGN KEY (chunk_id) REFERENCES memory_index_chunks(id) ON DELETE CASCADE\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS memory_entry_origins (\n entry_key TEXT NOT NULL,\n agent_id TEXT NOT NULL,\n session_id TEXT NOT NULL,\n session_key TEXT,\n origin_class TEXT NOT NULL CHECK (origin_class IN ('owner', 'agent', 'untrusted', 'system')),\n observed_at INTEGER NOT NULL,\n PRIMARY KEY (entry_key, agent_id, session_id)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS memory_session_tombstones (\n session_id TEXT NOT NULL PRIMARY KEY,\n agent_id TEXT NOT NULL,\n reason TEXT NOT NULL,\n created_at INTEGER NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS memory_embedding_cache (\n provider TEXT NOT NULL,\n model TEXT NOT NULL,\n provider_key TEXT NOT NULL,\n hash TEXT NOT NULL,\n embedding BLOB NOT NULL,\n dims INTEGER,\n updated_at INTEGER NOT NULL,\n PRIMARY KEY (provider, model, provider_key, hash)\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS memory_index_state (\n id INTEGER PRIMARY KEY CHECK (id = 1),\n revision INTEGER NOT NULL\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS standing_intents (\n intent_key INTEGER PRIMARY KEY,\n id TEXT NOT NULL UNIQUE,\n description TEXT NOT NULL,\n trigger_keywords TEXT NOT NULL,\n trigger_embedding TEXT,\n channel_scope TEXT,\n sender_scope TEXT,\n creator_sender TEXT CHECK (creator_sender IS NULL OR length(trim(creator_sender)) > 0),\n status TEXT NOT NULL CHECK (status IN ('pending', 'armed', 'fired', 'done', 'cancelled', 'expired')),\n expires_at INTEGER NOT NULL,\n max_fires INTEGER NOT NULL CHECK (max_fires > 0),\n fire_count INTEGER NOT NULL DEFAULT 0 CHECK (fire_count >= 0),\n cooldown_seconds INTEGER NOT NULL DEFAULT 86400 CHECK (cooldown_seconds >= 0),\n last_fired_at INTEGER,\n created_at INTEGER NOT NULL,\n source_session_id TEXT\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_standing_intents_lifecycle\n ON standing_intents(status, expires_at, last_fired_at);\n\nCREATE INDEX IF NOT EXISTS idx_standing_intents_scope\n ON standing_intents(status, channel_scope, sender_scope);\n\nCREATE VIRTUAL TABLE IF NOT EXISTS standing_intents_fts USING fts5(\n trigger_keywords,\n content = 'standing_intents',\n content_rowid = 'intent_key',\n tokenize = 'unicode61 remove_diacritics 2'\n);\n\nCREATE TRIGGER IF NOT EXISTS standing_intents_fts_after_insert\nAFTER INSERT ON standing_intents\nBEGIN\n INSERT INTO standing_intents_fts(rowid, trigger_keywords)\n VALUES (new.intent_key, new.trigger_keywords);\nEND;\n\nCREATE TRIGGER IF NOT EXISTS standing_intents_fts_after_delete\nAFTER DELETE ON standing_intents\nBEGIN\n INSERT INTO standing_intents_fts(standing_intents_fts, rowid, trigger_keywords)\n VALUES ('delete', old.intent_key, old.trigger_keywords);\nEND;\n\nCREATE TRIGGER IF NOT EXISTS standing_intents_fts_after_update\nAFTER UPDATE OF trigger_keywords ON standing_intents\nBEGIN\n INSERT INTO standing_intents_fts(standing_intents_fts, rowid, trigger_keywords)\n VALUES ('delete', old.intent_key, old.trigger_keywords);\n INSERT INTO standing_intents_fts(rowid, trigger_keywords)\n VALUES (new.intent_key, new.trigger_keywords);\nEND;\n\nCREATE TABLE IF NOT EXISTS session_transcript_index_state (\n session_id TEXT NOT NULL PRIMARY KEY,\n indexed_seq INTEGER NOT NULL,\n leaf_event_id TEXT,\n needs_rebuild INTEGER NOT NULL DEFAULT 0,\n active_event_count INTEGER NOT NULL DEFAULT 0,\n active_message_count INTEGER NOT NULL DEFAULT 0,\n updated_at INTEGER NOT NULL,\n FOREIGN KEY (session_id) REFERENCES session_windows(session_id) ON DELETE CASCADE\n) STRICT;\n\nCREATE TABLE IF NOT EXISTS session_transcript_active_events (\n session_id TEXT NOT NULL,\n active_position INTEGER NOT NULL CHECK (active_position >= 0),\n event_seq INTEGER NOT NULL,\n message_position INTEGER CHECK (message_position IS NULL OR message_position >= 0),\n context_eligible INTEGER,\n PRIMARY KEY (session_id, active_position),\n FOREIGN KEY (session_id, event_seq) REFERENCES transcript_events(session_id, seq) ON DELETE CASCADE\n) STRICT;\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_agent_transcript_active_event_seq\n ON session_transcript_active_events(session_id, event_seq);\n\nCREATE UNIQUE INDEX IF NOT EXISTS idx_agent_transcript_active_messages\n ON session_transcript_active_events(session_id, message_position)\n WHERE message_position IS NOT NULL;\n\nCREATE INDEX IF NOT EXISTS idx_agent_transcript_context_pending\n ON session_transcript_active_events(session_id)\n WHERE context_eligible IS NULL;\n\nCREATE VIRTUAL TABLE IF NOT EXISTS session_transcript_fts USING fts5(\n text,\n session_id UNINDEXED,\n message_id UNINDEXED,\n role UNINDEXED,\n timestamp UNINDEXED,\n tokenize = 'unicode61 remove_diacritics 2'\n);\n\nCREATE TABLE IF NOT EXISTS session_transcript_fts_rows (\n id INTEGER PRIMARY KEY,\n session_id TEXT NOT NULL,\n message_id TEXT\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_session_transcript_fts_rows_session_message\n ON session_transcript_fts_rows(session_id, message_id);\n\nCREATE TRIGGER IF NOT EXISTS session_transcript_fts_rows_after_delete\nAFTER DELETE ON session_transcript_fts_rows\nBEGIN\n DELETE FROM session_transcript_fts WHERE rowid = OLD.id;\nEND;\n\nINSERT OR IGNORE INTO memory_index_state (id, revision) VALUES (1, 0);\n\nCREATE TRIGGER IF NOT EXISTS memory_index_sources_revision_after_insert\nAFTER INSERT ON memory_index_sources\nBEGIN\n UPDATE memory_index_state SET revision = revision + 1 WHERE id = 1;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS memory_index_sources_revision_after_update\nAFTER UPDATE ON memory_index_sources\nBEGIN\n UPDATE memory_index_state SET revision = revision + 1 WHERE id = 1;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS memory_index_sources_revision_after_delete\nAFTER DELETE ON memory_index_sources\nBEGIN\n UPDATE memory_index_state SET revision = revision + 1 WHERE id = 1;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS memory_index_chunks_revision_after_insert\nAFTER INSERT ON memory_index_chunks\nBEGIN\n UPDATE memory_index_state SET revision = revision + 1 WHERE id = 1;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS memory_index_chunks_revision_after_update\nAFTER UPDATE ON memory_index_chunks\nBEGIN\n UPDATE memory_index_state SET revision = revision + 1 WHERE id = 1;\nEND;\n\nCREATE TRIGGER IF NOT EXISTS memory_index_chunks_revision_after_delete\nAFTER DELETE ON memory_index_chunks\nBEGIN\n UPDATE memory_index_state SET revision = revision + 1 WHERE id = 1;\nEND;\n\nCREATE INDEX IF NOT EXISTS idx_memory_embedding_cache_updated_at\n ON memory_embedding_cache(updated_at);\n\nCREATE INDEX IF NOT EXISTS idx_memory_index_sources_source\n ON memory_index_sources(source);\n\nCREATE INDEX IF NOT EXISTS idx_memory_index_chunks_path_source\n ON memory_index_chunks(path, source);\n\nCREATE INDEX IF NOT EXISTS idx_memory_index_chunks_path\n ON memory_index_chunks(path);\n\nCREATE INDEX IF NOT EXISTS idx_memory_index_chunks_source\n ON memory_index_chunks(source);\n\n-- Accepted input stays outside the active transcript until its exact turn owns execution.\nCREATE TABLE IF NOT EXISTS session_pending_inputs (\n seq INTEGER PRIMARY KEY AUTOINCREMENT,\n input_id TEXT NOT NULL UNIQUE,\n session_key TEXT NOT NULL,\n session_id TEXT NOT NULL,\n idempotency_key TEXT NOT NULL,\n run_id TEXT NOT NULL,\n request_hash TEXT NOT NULL,\n message_json TEXT NOT NULL,\n lifecycle_generation TEXT NOT NULL,\n state TEXT NOT NULL CHECK (state IN ('queued', 'interrupted', 'cancelled')),\n accepted_at INTEGER NOT NULL,\n consumed_event_id TEXT,\n UNIQUE (session_id, idempotency_key),\n FOREIGN KEY (session_key) REFERENCES session_nodes(session_key) ON DELETE CASCADE,\n FOREIGN KEY (session_id) REFERENCES session_windows(session_id) ON DELETE CASCADE\n) STRICT;\n\nCREATE INDEX IF NOT EXISTS idx_agent_session_pending_inputs_session\n ON session_pending_inputs(session_key, session_id, seq DESC);\n\n-- Processing completion is separate from input consumption; neither schedules replay.\nCREATE TABLE IF NOT EXISTS session_input_completions (\n session_key TEXT NOT NULL,\n session_id TEXT NOT NULL,\n idempotency_key TEXT NOT NULL,\n run_id TEXT NOT NULL,\n request_hash TEXT NOT NULL,\n outcome_json TEXT NOT NULL,\n succeeded INTEGER NOT NULL CHECK (succeeded IN (0, 1)),\n completed_at INTEGER NOT NULL,\n PRIMARY KEY (session_id, idempotency_key),\n FOREIGN KEY (session_key) REFERENCES session_nodes(session_key) ON DELETE CASCADE,\n FOREIGN KEY (session_id) REFERENCES session_windows(session_id) ON DELETE CASCADE\n) STRICT;\n";
//#endregion
//#region src/state/openclaw-agent-db-additive-columns.ts
const SESSION_OWNER_COLUMN_DEFINITIONS = [
{
columnName: "owner_actor_type",
dataType: "TEXT",
tableName: "session_nodes"
},
{
columnName: "owner_actor_id",
dataType: "TEXT",
tableName: "session_nodes"
},
{
columnName: "owner_assigned_by_type",
dataType: "TEXT",
tableName: "session_nodes"
},
{
columnName: "owner_assigned_by_id",
dataType: "TEXT",
tableName: "session_nodes"
},
{
columnName: "owner_assigned_at",
dataType: "INTEGER",
tableName: "session_nodes"
}
];
const LEGACY_ACP_MIGRATION_COLUMN_DEFINITION = {
columnName: "legacy_acp_migration_json",
dataType: "TEXT",
tableName: "session_nodes"
};
const CANONICAL_READY_COLUMN_DEFINITION = {
columnName: "canonical_ready",
dataType: "TEXT",
tableName: "session_key_contract"
};
const FIRST_USE_ADDITIVE_AGENT_COLUMN_DEFINITIONS = [
...SESSION_OWNER_COLUMN_DEFINITIONS,
LEGACY_ACP_MIGRATION_COLUMN_DEFINITION,
CANONICAL_READY_COLUMN_DEFINITION
];
//#endregion
//#region src/state/openclaw-state-db-schema-helpers.ts
function tableHasColumn(db, tableName, columnName) {
return tableHasColumns(db, tableName, [columnName]);
}
function tableHasColumns(db, tableName, columnNames) {
const existing = readTableColumns(db, tableName);
return columnNames.every((columnName) => existing.has(columnName));
}
function readTableColumns(db, tableName) {
const rows = db.prepare(`PRAGMA table_info(${tableName})`).all();
return new Set(rows.flatMap((row) => typeof row.name === "string" ? [row.name] : []));
}
/** Inspect only failed queries; native unavailability must not become a schema refusal. */
function classifySqliteTableReadError(db, tableName, columnNames, error) {
if (sqlitePrimaryResultCode(error) !== 1) return error;
try {
const existing = readTableColumns(db, tableName);
if (existing.size > 0 && columnNames.some((column) => !existing.has(column))) return new SqliteSchemaMismatchError(`SQLite table ${tableName} is missing required columns; run openclaw doctor --fix to repair it.`, { cause: error });
} catch {}
return error;
}
function tablePrimaryKeyColumns(db, tableName) {
return db.prepare(`PRAGMA table_info(${tableName})`).all().filter((row) => Number(row.pk ?? 0) > 0 && typeof row.name === "string").toSorted((left, right) => Number(left.pk ?? 0) - Number(right.pk ?? 0)).map((row) => row.name);
}
function tableExists(db, tableName) {
const schema = getAdmittedSqliteSchemaFacts(db);
if (schema) return schema.tables.has(tableName);
return executeWithCachedStatement(db, "SELECT 1 AS ok FROM sqlite_master WHERE type = 'table' AND name = ?", [tableName], (statement) => statement.get(tableName))?.ok === 1;
}
function ensureColumn(db, tableName, columnSql) {
const columnName = columnSql.trim().split(/\s+/, 1)[0];
if (!columnName || !tableExists(db, tableName) || tableHasColumn(db, tableName, columnName)) return false;
db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnSql};`);
return true;
}
//#endregion
//#region src/state/openclaw-agent-board-schema.ts
const OPENCLAW_AGENT_BOARD_SCHEMA_SQL = extractSqliteTableSchema(OPENCLAW_AGENT_SCHEMA_SQL, "board_tabs", {
endMarker: "CREATE TABLE IF NOT EXISTS session_progress_cards (",
includeEndMarker: false,
errorMessage: "OpenClaw agent board schema markers are missing from the canonical schema."
});
const OPENCLAW_AGENT_SCHEMA_WITHOUT_BOARD_SQL = OPENCLAW_AGENT_SCHEMA_SQL.replace(OPENCLAW_AGENT_BOARD_SCHEMA_SQL, "");
const AGENT_PROGRESS_CARD_SCHEMA_SQL = extractSqliteTableSchema(OPENCLAW_AGENT_SCHEMA_WITHOUT_BOARD_SQL, "session_progress_cards", {
endMarker: "CREATE TABLE IF NOT EXISTS heartbeat_outcomes (",
includeEndMarker: false,
errorMessage: "OpenClaw agent progress-card schema markers are missing."
});
OPENCLAW_AGENT_SCHEMA_WITHOUT_BOARD_SQL.replace(AGENT_PROGRESS_CARD_SCHEMA_SQL, "");
[...FIRST_USE_ADDITIVE_AGENT_COLUMN_DEFINITIONS.map(({ columnName, tableName }) => `${tableName}.${columnName}`)];
resolveGlobalSingleton(Symbol.for("openclaw.agentDatabaseSettledReadOpenFailures"), () => /* @__PURE__ */ new WeakSet());
resolveGlobalSingleton(Symbol.for("openclaw.agentCanonicalValidationSchemas"), () => /* @__PURE__ */ new WeakMap());
resolveGlobalSingleton(Symbol.for("openclaw.agentDatabaseIdentities"), () => /* @__PURE__ */ new WeakMap());
resolveGlobalSingleton(Symbol.for("openclaw.agentDatabaseAsyncResources"), () => ({
active: /* @__PURE__ */ new Set(),
closing: /* @__PURE__ */ new Map(),
selections: /* @__PURE__ */ new Map()
}));
//#endregion
//#region src/state/openclaw-agent-db-validation-cache.ts
const validatedPaths = resolveGlobalSingleton(Symbol.for("openclaw.agentDatabaseValidatedPaths"), () => /* @__PURE__ */ new Map(), () => clearOpenClawAgentDatabaseValidationCache());
resolveGlobalSingleton(Symbol.for("openclaw.agentDatabaseValidationBindings"), () => /* @__PURE__ */ new WeakMap());
function invalidateOpenClawAgentDatabaseValidation(pathname, identity) {
const resolved = resolveDatabasePathKey(pathname);
const currentIdentity = identity ?? validatedPaths.get(resolved)?.validation?.identity;
const paths = /* @__PURE__ */ new Set([resolved]);
if (currentIdentity) {
for (const [candidate, entry] of validatedPaths) if (entry.validation?.identity === currentIdentity) paths.add(candidate);
}
for (const candidate of paths) {
const entry = validatedPaths.get(candidate);
const validation = entry?.validation;
if (validation) Atomics.store(new Int32Array(validation.valid), 0, 0);
validatedPaths.set(candidate, {
agentId: entry?.agentId,
validation,
integrityVerified: false,
revoked: true
});
}
}
function clearOpenClawAgentDatabaseValidationCache(rootPath) {
const rootKey = rootPath === void 0 ? void 0 : resolveDatabasePathKey(rootPath);
for (const pathname of validatedPaths.keys()) if (rootKey === void 0 || isPathInside$1(rootKey, pathname)) {
invalidateOpenClawAgentDatabaseValidation(pathname);
validatedPaths.delete(pathname);
}
}
//#endregion
//#region src/state/openclaw-quarantine-store.ts
const OPENCLAW_QUARANTINE_SCHEMA_VERSION = 2;
const OPENCLAW_QUARANTINE_BUSY_TIMEOUT_MS = 5e3;
function createOpenClawDatabaseVerificationError(kind, pathname, storedError) {
const error = /* @__PURE__ */ new Error(`OpenClaw ${kind} database ${pathname} is quarantined after integrity verification failed: ${storedError ?? "unknown integrity error"}. Restore the database from a backup or repair it, then run openclaw doctor --fix to clear the quarantine. See ${OPENCLAW_DATABASE_SCHEMA_DOCS_URL}.`);
error.name = "SqliteIntegrityError";
return error;
}
function readQuarantineSchemaVersion(database, storePath) {
const userVersion = database.prepare("PRAGMA user_version").get()?.user_version;
if (typeof userVersion !== "number" || !Number.isInteger(userVersion)) throw new Error(`OpenClaw quarantine store ${storePath} has an invalid schema version.`);
return userVersion;
}
/** Read one authoritative quarantine decision without creating the store. */
function readOpenClawDatabaseQuarantine(pathname, options = {}) {
const storePath = resolveQuarantineStorePath(options.env ?? process.env);
if (!existsSync(storePath)) return;
const database = openNodeSqliteDatabase(storePath);
let outcome;
try {
outcome = { value: readQuarantineDecision(database, pathname, storePath) };
} catch (error) {
outcome = { error };
}
try {
database.close();
} catch (closeError) {
throw new OpenClawQuarantineReadCleanupError("error" in outcome ? [outcome.error, closeError] : [closeError], "value" in outcome ? outcome.value : void 0);
}
if ("error" in outcome) throw outcome.error;
return outcome.value;
}
function readQuarantineDecision(database, pathname, storePath) {
database.exec(`PRAGMA busy_timeout = ${OPENCLAW_QUARANTINE_BUSY_TIMEOUT_MS};`);
const userVersion = readQuarantineSchemaVersion(database, storePath);
if (userVersion === 0) return;
if (userVersion > OPENCLAW_QUARANTINE_SCHEMA_VERSION) throw new Error(`OpenClaw quarantine store ${storePath} uses newer schema version ${userVersion}.`);
const generationColumn = userVersion >= 2 ? ", verified_generation" : "";
const row = database.prepare(`SELECT kind, reason, quarantined_at${generationColumn} FROM quarantined_databases WHERE path = ? LIMIT 1`).get(path.resolve(pathname));
if (!row) return;
if (row.kind !== "agent" && row.kind !== "state" || typeof row.reason !== "string" || typeof row.quarantined_at !== "number" || !Number.isInteger(row.quarantined_at) || row.verified_generation !== void 0 && row.verified_generation !== null && typeof row.verified_generation !== "string") throw new Error(`OpenClaw quarantine store ${storePath} contains an invalid row.`);
if (typeof row.verified_generation === "string") {
let verifiedGeneration;
try {
verifiedGeneration = parseSqliteFileGeneration(row.verified_generation);
} catch {
throw new Error(`OpenClaw quarantine store ${storePath} contains an invalid row.`);
}
try {
const currentGeneration = readStableSqliteFileGeneration(path.resolve(pathname));
if (!sameSqliteFileGeneration(verifiedGeneration, currentGeneration)) return;
} catch {
return;
}
}
return {
kind: row.kind,
quarantinedAt: row.quarantined_at,
reason: row.reason
};
}
/** Runtime opens refuse recorded damage while tolerating a broken quarantine index. */
function readOpenClawDatabaseQuarantineFailure(kind, pathname, options = {}) {
let quarantine;
let cleanupFailure;
try {
quarantine = readOpenClawDatabaseQuarantine(pathname, options);
} catch (error) {
if (!(error instanceof OpenClawQuarantineReadCleanupError)) return;
if (!error.quarantine) throw error;
quarantine = error.quarantine;
cleanupFailure = error;
}
if (!quarantine) return;
const failure = createOpenClawDatabaseVerificationError(kind, pathname, quarantine.reason);
if (cleanupFailure) failure.cause = cleanupFailure;
return failure;
}
//#endregion
//#region src/state/openclaw-state-db-borrow.ts
/** The canonical cache supplies identity and custody; this owner manages its native references. */
function createStateDatabaseRetainer(state, operations) {
const admit = (pathname, ownership) => {
const scope = getOpenClawDatabaseMaintenanceScope();
if (ownership === "cached-read") scope?.assertReadAdmission();
else scope?.assertAdmission();
operations.assertOpen(pathname, ownership);
return scope;
};
const retain = (database, scope, readOnly = false) => {
operations.capture(database.path).assertCurrent();
if (state.cachedDatabases.get(database.path) !== database || !database.db.isOpen) throw new Error("OpenClaw state database borrow requires its current canonical handle");
const owner = state.borrowers.get(database.db) ?? {
references: /* @__PURE__ */ new Set(),
retiring: false,
cleanupComplete: false
};
if (owner.retiring) throw new Error("OpenClaw state database native owner is retiring");
if (!readOnly) observeOpenClawDatabaseMaintenanceResource(database.db);
state.borrowers.set(database.db, owner);
const isCurrent = () => !scope || isOpenClawDatabaseMaintenanceResourceOwned(database.db, scope);
const reference = retainStateDatabaseReference({
owner,
retirement: readOnly ? void 0 : {
ordinary: scope === void 0,
isCurrent,
retire: () => {
if (!isCurrent()) {
owner.retiring = false;
return;
}
operations.retire(database, scope === void 0);
}
},
retainFailedClose: () => operations.retainFailed(database)
});
scope?.own(reference, "shared-references", () => reference.release());
return reference;
};
const findReadDatabase = (pathname, ownership) => {
const scope = admit(pathname, ownership);
const database = state.cachedDatabases.get(path.resolve(pathname));
return {
database: database?.db.isOpen ? database : void 0,
scope
};
};
const retainReadReference = (database, scope) => {
const reference = retain(database, scope, true);
const assertCurrent = () => {
if (state.cachedDatabases.get(database.path) !== database || !database.db.isOpen) throw new Error("Shared-state read lost its original native owner");
};
return {
assertCurrent,
observe() {
assertCurrent();
observeOpenClawDatabaseMaintenanceResource(database.db);
},
release() {
reference.release();
operations.touch(database);
}
};
};
return {
retain: (database) => retain(database, admit(database.path)),
retainForIndependentRead(pathname, ownership) {
const { database, scope } = findReadDatabase(pathname, ownership);
return database ? retainReadReference(database, scope) : void 0;
},
borrowForRead(pathname, ownership) {
const { database, scope } = findReadDatabase(pathname, ownership);
if (!database) return;
if (database.db.isTransaction) throw new Error("Asynchronous shared-state reads cannot run inside a native transaction");
return {
database,
...retainReadReference(database, scope)
};
}
};
}
function assertStateDatabaseBorrowersReleased(owner, pathname) {
if (owner?.references.size) throw new Error(`OpenClaw state database still has active native borrowers: ${pathname}`);
}
/** Preserve the requesting owner's retirement when the last reference is only a read pin. */
function retainStateDatabaseReference(params) {
const { owner } = params;
const reference = {};
owner.references.add(reference);
let released = false;
return { release() {
if (released || owner.cleanupComplete) {
released = true;
return;
}
owner.references.delete(reference);
if (owner.retirement && !owner.retirement.isCurrent()) {
owner.retirement = void 0;
owner.retiring = false;
}
if (params.retirement?.isCurrent() && !owner.retirement?.ordinary) owner.retirement = params.retirement;
if (owner.references.size > 0 || !owner.retirement) {
released = true;
return;
}
owner.retiring = true;
try {
owner.retirement.retire();
} catch (error) {
params.retainFailedClose();
throw error;
}
owner.retirement = void 0;
released = true;
} };
}
//#endregion
//#region src/infra/sqlite-handle-lifecycle.ts
/** Idle native connections share one retention window across SQLite owners. */
const SQLITE_IDLE_HANDLE_TTL_MS = 18e5;
//#endregion
//#region src/state/openclaw-state-db-cache.idle.ts
const log = createSubsystemLogger("state/db");
/** Schedule native retirement against the canonical cache's handles and borrow pins. */
function createStateDatabaseIdleRetirement({ cachedDatabases, retainedDatabaseHandles, idleTimers, idleReferences, borrowers }, retire) {
const touch = (database) => {
if (!(cachedDatabases.get(database.path) === database && database.db.isOpen) && retainedDatabaseHandles.get(database.db) !== database) return;
const previous = idleTimers.get(database.db);
if (previous) {
previous.refresh();
return;
}
const timer = runInSqliteMaintenanceContext(() => setTimeout(() => {
idleTimers.delete(database.db);
try {
if (database.db.isOpen && (database.db.isTransaction || borrowers.get(database.db)?.references.size || idleReferences.get(database.db)?.size)) {
touch(database);
return;
}
retire(database, false, {
busyTimeoutMs: 0,
checkpointMode: "PASSIVE"
});
} catch (error) {
log.warn("Idle shared-state database cleanup failed", {
path: database.path,
error
});
touch(database);
}
}, SQLITE_IDLE_HANDLE_TTL_MS));
timer.unref();
idleTimers.set(database.db, timer);
};
return {
touch,
/** Retained consumers postpone idle eviction without blocking explicit retirement. */
retain(database) {
if (cachedDatabases.get(database.path) !== database || !database.db.isOpen || borrowers.get(database.db)?.retiring) throw new Error("OpenClaw state database idle retention requires its current canonical handle");
const references = idleReferences.get(database.db) ?? /* @__PURE__ */ new Set();
const reference = {};
references.add(reference);
idleReferences.set(database.db, references);
return () => {
if (!references.delete(reference)) return;
if (cachedDatabases.get(database.path) === database && database.db.isOpen) touch(database);
};
}
};
}
//#endregion
//#region src/infra/sqlite-worker-contract.ts
const SQLITE_WORKER_MAX_MESSAGE_BYTES = 33554432;
const retainedWorkerErrorCode = Symbol.for("openclaw.sqliteWorkerErrorCode");
const SqliteWorkerAdmissionTimeoutError = resolveGlobalSingleton(Symbol.for("openclaw.sqliteWorkerAdmissionTimeoutError"), () => class AdmissionTimeoutError extends Error {
constructor() {
super("SQLite host admission timed out; retry after transaction rollback");
this.code = "admission-timeout";
this.name = "SqliteWorkerAdmissionTimeoutError";
}
});
var SqliteWorkerError = class extends Error {
constructor(message, code) {
super(message);
this.code = code;
this.name = "SqliteWorkerError";
Object.defineProperty(this, retainedWorkerErrorCode, { value: code });
}
};
/** Carry only canonical worker classification through a local cleanup aggregate. */
function retainSqliteWorkerErrorCode(error, source) {
let code;
try {
code = Object.getOwnPropertyDescriptor(source, retainedWorkerErrorCode)?.value;
} catch {
return error;
}
if (code === "closed" || code === "overloaded" || code === "unavailable" || code === "outcome-unknown") {
Object.defineProperty(error, retainedWorkerErrorCode, { value: code });
Object.assign(error, { code });
}
return error;
}
//#endregion
//#region src/infra/sqlite-worker-operation-admission.ts
const REQUESTED = 0;
const GRANTED = 1;
const REFUSED = 2;
const TIMED_OUT = 3;
resolveGlobalSingleton(Symbol.for("openclaw.sqliteWorkerOpenRefusedError"), () => class OpenRefusedError extends Error {
constructor(originalError) {
super("SQLite worker admission was refused before agent open", { cause: originalError });
this.originalError = originalError;
this.name = "SqliteWorkerOpenRefusedError";
}
});
/** The caller retains real source custody before invoking the synchronous grant. */
function createSqliteWorkerOperationAdmission(admit, attachment) {
const { port1, port2 } = new MessageChannel();
if (attachment !== void 0) try {
port1.postMessage({
kind: "sqlite-operation-attachment",
value: attachment
}, []);
} catch (error) {
port1.close();
port2.close();
throw error;
}
const inOwnerContext = AsyncLocalStorage.snapshot();
const decisions = /* @__PURE__ */ new Set();
const cleanupFailures = [];
let closed = false;
let failure;
let committed;
let settlement;
let databaseAuthority;
const waiting = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
const recordFailure = (error, source) => {
if (!failure || failure.source === "domain" && source !== "domain") failure = {
error,
source
};
};
const refuse = (decision, error, source) => {
if (Atomics.compareExchange(decision, 0, REQUESTED, REFUSED) === REQUESTED) {
recordFailure(error, source);
Atomics.notify(decision, 0);
} else if (Atomics.load(decision, 0) === GRANTED) cleanupFailures.push(error);
};
const receive = (message) => {
if (isRecord(message) && message.kind === "native-commit") {
if (!isRecord(message.committed) || settlement) {
recordFailure(new SqliteWorkerError("SQLite worker commit receipt is invalid", "outcome-unknown"), "protocol");
return;
}
committed = { facts: message.committed.facts };
return;
}
if (isRecord(message) && message.kind === "native-settlement") {
const value = message.settlement;
if (!isRecord(value) || value.kind !== "completed" && value.kind !== "unknown" || value.committed !== void 0 && !isRecord(value.committed) || settlement) {
recordFailure(new SqliteWorkerError("SQLite worker native settlement is invalid", "outcome-unknown"), "protocol");
return;
}
if (isRecord(value.committed)) committed = { facts: value.committed.facts };
settlement = {
kind: value.kind,
...committed ? { committed } : {}
};
return;
}
if (!isRecord(message) || !(message.decision instanceof SharedArrayBuffer) || message.decision.byteLength !== Int32Array.BYTES_PER_ELEMENT || message.stage !== "open" && message.stage !== "prepare" && message.stage !== "transaction" && message.stage !== "commit") {
recordFailure(new SqliteWorkerError("SQLite worker admission request is invalid", "unavailable"), "protocol");
return;
}
const decision = new Int32Array(message.decision);
const expired = () => {
if (typeof message.deadlineNs === "bigint" && process.hrtime.bigint() >= message.deadlineNs) {
if (Atomics.compareExchange(decision, 0, REQUESTED, TIMED_OUT) === REQUESTED) Atomics.notify(decision, 0);
}
if (Atomics.load(decision, 0) !== TIMED_OUT) return false;
if (Array.isArray(message.ports)) {
for (const port of message.ports) if (port instanceof MessagePort) port.close();
}
return true;
};
if (expired()) return;
decisions.add(decision);
if (closed) {
refuse(decision, new SqliteWorkerError("SQLite worker admission is closed", "closed"), "authority");
return;
}
const request = {
stage: message.stage,
facts: message.facts
};
const grant = () => {
if (closed || expired() || Atomics.load(decision, 0) !== REQUESTED) return false;
try {
inOwnerContext(() => databaseAuthority?.assertAccess());
} catch (error) {
refuse(decision, error, "authority");
return false;
}
if (closed || expired() || Atomics.load(decision, 0) !== REQUESTED) return false;
const granted = Atomics.compareExchange(decision, 0, REQUESTED, GRANTED) === REQUESTED;
if (granted) Atomics.notify(decision, 0);
return granted;
};
let source = "authority";
try {
inOwnerContext(() => {
databaseAuthority?.assertRequest?.();
databaseAuthority?.assertAccess();
});
if (request.stage === "prepare" && isRecord(request.facts) && request.facts.kind === "schema-maintenance") {
const authority = databaseAuthority;
if (!authority || typeof request.facts.databasePath !== "string" || resolveIdentityPathViaExistingAncestorSync(request.facts.databasePath) !== authority.databasePath) throw new SqliteWorkerError("SQLite schema maintenance target differs from its admitted database", "closed");
inOwnerContext(() => {
authority.lease ??= authority.acquireSchema();
authority.lease.assertCurrent();
grant();
});
} else {
source = "domain";
inOwnerContext(admit, request, grant);
}
} catch (error) {
refuse(decision, error, source);
return;
} finally {
decisions.delete(decision);
}
if (Atomics.load(decision, 0) === REQUESTED) refuse(decision, new SqliteWorkerError("SQLite worker admission was not granted", "closed"), "domain");
};
port1.on("message", receive);
port1.unref();
const service = () => {
for (let queued = receiveMessageOnPort(port1); queued; queued = receiveMessageOnPort(port1)) receive(queued.message);
};
return {
port: port2,
bindDatabaseAuthority(authority) {
if (closed || databaseAuthority) throw new SqliteWorkerError("SQLite database authority is already bound or closed", "closed");
databaseAuthority = {
...authority,
databasePath: resolveIdentityPathViaExistingAncestorSync(authority.databasePath)
};
},
get failure() {
return failure?.error;
},
get failureSource() {
return failure?.source;
},
get cleanupFailures() {
return cleanupFailures;
},
get committed() {
service();
return committed;
},
get settlement() {
return settlement;
},
waitForSettlement(deadlineMs) {
while (true) {
service();
if (failure !== void 0) throw toErrorObject(failure.error, "SQLite worker admission failed");
if (settlement?.kind === "completed") return settlement;
const remaining = deadlineMs - performance.now();
if (settlement?.kind === "unknown" || closed || remaining <= 0) throw new SqliteWorkerError("SQLite worker native settlement is unknown", "outcome-unknown");
Atomics.wait(waiting, 0, 0, Math.min(5, remaining));
}
},
service,
finish() {
closed = true;
service();
for (const decision of decisions) if (Atomics.load(decision, 0) === REQUESTED) refuse(decision, new SqliteWorkerError("SQLite worker admission is closed", "closed"), "authority");
port1.close();
port2.close();
if (databaseAuthority?.lease) try {
databaseAuthority.lease.release();
databaseAuthority.lease = void 0;
} catch (error) {
cleanupFailures.push(error);
}
}
};
}
const currentAdmission = resolveGlobalSingleton(Symbol.for("openclaw.sqliteWorkerOperationAdmission"), () => new AsyncLocalStorage());
/** Called on the SQLite worker, after transaction entry and before its row mutation. */
function requestSqliteWorkerOperationAdmission(request, transferList = []) {
const scope = currentAdmission.getStore();
if (!scope?.active) throw new SqliteWorkerError("SQLite operation requires its retained admission", "unavailable");
const decision = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
const deadlineNs = request.deadlineMs === void 0 ? void 0 : process.hrtime.bigint() + BigInt(request.deadlineMs) * 1000000n;
scope.port.postMessage({
...request,
decision: decision.buffer,
deadlineNs,
ports: transferList.filter((value) => value instanceof MessagePort)
}, transferList);
while (Atomics.load(decision, 0) === REQUESTED) {
const remainingMs = deadlineNs === void 0 ? void 0 : Number(deadlineNs - process.hrtime.bigint()) / 1e6;
if (remainingMs !== void 0 && remainingMs <= 0) Atomics.compareExchange(decision, 0, REQUESTED, TIMED_OUT);
else Atomics.wait(decision, 0, REQUESTED, remainingMs);
}
if (Atomics.load(decision, 0) !== GRANTED) {
const refusal = Atomics.load(decision, 0) === TIMED_OUT ? new SqliteWorkerAdmissionTimeoutError() : new SqliteWorkerError("SQLite transaction admission was refused", "closed");
scope.owner.refusal = refusal;
throw refusal;
}
}
/** Schema work borrows live host authority through the same retained job port. */
function requestSqliteWorkerSchemaMaintenance(databasePath) {
if (!currentAdmission.getStore()) return false;
requestSqliteWorkerOperationAdmission({
stage: "prepare",
facts: {
kind: "schema-maintenance",
databasePath
}
});
return true;
}
//#endregion
//#region src/infra/gateway-supervision.ts
const GATEWAY_SUPERVISOR_MODE_ENV = "OPENCLAW_SUPERVISOR_MODE";
function isGatewayExternallySupervised(env = process.env) {
return env[GATEWAY_SUPERVISOR_MODE_ENV]?.trim().toLowerCase() === "external";
}
//#endregion
//#region src/state/openclaw-state-db-schema-policy.ts
const schemaPolicies = resolveGlobalSingleton(Symbol.for("openclaw.stateDatabaseSchemaPolicies"), () => ({
scopes: new AsyncLocalStorage(),
existingDatabases: /* @__PURE__ */ new WeakMap()
}));
function canonicalPath(pathname) {
const resolved = path.resolve(pathname);
try {
return realpathSync.native(resolved);
} catch (error) {
if (hasErrnoCode(error, "ENOENT")) return resolved;
throw error;
}
}
function assertSchemaScopeActive(scope) {
if (scope && !scope.active) throw new Error("Existing shared-state schema admission has ended.");
}
function getExistingOpenClawStateSchemaPath() {
const scope = schemaPolicies.scopes.getStore();
assertSchemaScopeActive(scope);
return scope?.path;
}
/** Admit this source once; retained reads only need the original scope's live lifetime. */
function captureOpenClawStateSchemaReadAdmission(pathname) {
const scope = schemaPolicies.scopes.getStore();
if (!scope) return;
isExistingOpenClawStateSchema(pathname);
return {
path: scope.path,
assertCurrent: () => assertSchemaScopeActive(scope)
};
}
/** Check supplied and cached handles before exposing them to another admission policy. */
function isExistingOpenClawStateSchema(pathname, database) {
const scopedPath = getExistingOpenClawStateSchemaPath();
const scope = schemaPolicies.scopes.getStore();
const admittedPath = database && schemaPolicies.existingDatabases.get(database);
const resolvedPath = path.resolve(pathname);
const existing = scopedPath !== void 0 && (scopedPath === resolvedPath || scope?.canonicalPath === resolvedPath || scope?.canonicalPath === canonicalPath(resolvedPath));
if (scopedPath && !existing) throw new Error(`Existing shared-state schema admission is bound to ${scopedPath}, not ${pathname}.`);
if (admittedPath && (!existing || admittedPath !== scope?.canonicalPath)) throw new Error(`Shared-state database ${pathname} was admitted without schema repair; close its existing handle before ordinary admission.`);
return existing;
}
function recordExistingOpenClawStateSchemaDatabase(database, pathname) {
const scope = schemaPolicies.scopes.getStore();
if (!scope || !isExistingOpenClawStateSchema(pathname, database)) throw new Error("Existing shared-state schema admission requires its active path scope.");
schemaPolicies.existingDatabases.set(database, scope.canonicalPath);
}
/** The cache owns the handle inventory, including owners retained after failed cleanup. */
function assertExistingOpenClawStateSchemaCacheAdmission(pathname, cache) {
const scopedPath = getExistingOpenClawStateSchemaPath();
const scope = schemaPolicies.scopes.getStore();
const requested = path.resolve(pathname);
let resolved = scope && (scopedPath === requested || scope.canonicalPath === requested) ? scope.canonicalPath : void 0;
for (const databases of [cache.cachedDatabases, cache.retainedDatabaseHandles]) for (const { db } of databases.values()) {
const admittedPath = schemaPolicies.existingDatabases.get(db);
if (admittedPath && db.isOpen) {
resolved ??= canonicalPath(pathname);
if (admittedPath === resolved) isExistingOpenClawStateSchema(pathname, db);
}
}
}
//#endregion
//#region src/state/openclaw-state-worker-context.capture.ts
/** Capture read authority without constructing a worker environment. */
function captureOpenClawStateReadContextWithAdmission(pathname, captureAdmission) {
const schema = captureOpenClawStateSchemaReadAdmission(pathname);
const capturedAdmission = captureAdmission(pathname);
let admission = capturedAdmission;
let runInCapturedSchemaScope;
if (schema) {
const inCapturedScope = AsyncLocalStorage.snapshot();
admission = {
databasePath: capturedAdmission.databasePath,
coordinationKey: capturedAdmission.coordinationKey,
get identity() {
return capturedAdmission.identity;
},
assertCurrent() {
capturedAdmission.assertCurrent();
schema.assertCurrent();
}
};
runInCapturedSchemaScope = (operation) => inCapturedScope(() => {
admission.assertCurrent();
return operation();
});
}
return {
maintenanceScope: getOpenClawDatabaseMaintenanceScope(),
admission,
existingSchemaPath: schema?.path,
runInCapturedSchemaScope
};
}
/** Read-only workers need resolved runtime facts, not the initialization environment. */
function captureOpenClawStateReadWorkerContextWithAdmission(options, captureAdmission) {
const source = options.env ?? process.env;
const env = process.platform === "win32" ? cloneEnvWithPlatformSemantics(source) : source;
const environment = {
OPENCLAW_STATE_DIR: resolveStateDir(env),
...isGatewayExternallySupervised(env) ? { OPENCLAW_SUPERVISOR_MODE: "external" } : {}
};
return {
...captureOpenClawStateReadContextWithAdmission(options.path ?? resolveOpenClawStateSqlitePath(environment), captureAdmission),
environment
};
}
/** Capture host facts before asynchronous work, without opening SQLite. */
function captureOpenClawStateWorkerContextWithAdmission(options, captureAdmission) {
const context = captureOpenClawStateReadWorkerContextWithAdmission(options, captureAdmission);
return {
...context,
initializationEnvironment: mergeProcessEnv([
options.env ?? process.env,
{
OPENCLAW_STATE_DIR: void 0,
OPENCLAW_SUPERVISOR_MODE: void 0
},
context.environment
]),
...options.initializationAgentPaths ? { initializationAgentPaths: options.initializationAgentPaths.map((agentPath) => path.resolve(agentPath)) } : {}
};
}
//#endregion
//#region src/state/openclaw-state-db-cache.wal.ts
/** Bind periodic maintenance and its observations to the cache's exact native owner. */
function createStateDatabaseWalOwner({ cachedDatabases, asyncResources }, retainForIdle) {
return {
register(database, identity, admission, env) {
if (!isMainThread) return;
const capturedContext = captureOpenClawStateWorkerContextWithAdmission({
path: database.path,
env
}, () => admission);
const controller = new AbortController();
let pending;
const cancel = () => {
controller.abort();
if (!pending) {
unregister();
return;
}
return pending.then(() => void 0, () => void 0);
};
const unregister = asyncResources.register({ async close(selected) {
if (selected && selected.key !== identity.key) return;
cancel();
await pending?.catch(() => {});
unregister();
} });
const run = async (request) => {
const maintenanceScope = getOpenClawDatabaseMaintenanceResourceScope(database.db);
const context = {
...capturedContext,
maintenanceScope
};
const assertCurrent = () => {
controller.signal.throwIfAborted();
context.admission.assertCurrent();
maintenanceScope?.assertAdmission();
if (getOpenClawDatabaseMaintenanceResourceScope(database.db) !== maintenanceScope || cachedDatabases.get(database.path) !== database || !database.db.isOpen) throw new StateDatabaseReadAdmissionInvalidatedError("Shared-state WAL maintenance owner changed");
assertExistingDatabaseIdentity(database.path, identity.key, identity.birthtime);
};
let releaseIdle;
let operationStarted = false;
try {
assertCurrent();
releaseIdle = retainForIdle(database);
const { runOpenClawStateWorkerOperation } = await import("./openclaw-state-worker-store-C-vikWR4.mjs");
assertCurrent();
const result = await runOpenClawStateWorkerOperation(context, (worker) => worker.execute({
type: "database.walMaintenance",
input: request
}, { signal: controller.signal }), {
existingOnly: true,
assertCurrent,
createAdmission: () => ({
nativeLocations: [database.path, identity.canonicalPath],
admission: createSqliteWorkerOperationAdmission((_request, grant) => {
assertCurrent();
if (!grant()) throw new StateDatabaseReadAdmissionInvalidatedError("Shared-state WAL maintenance authority expired");
operationStarted = true;
})
})
});
assertCurrent();
return result;
} catch (error) {
if (!operationStarted && (isStateDatabaseReadAdmissionInvalidatedError(error) || controller.signal.aborted && isAbortError(error))) return;
throw error;
} finally {
releaseIdle?.();
}
};
registerSqliteWalWorkerMaintenance(database.db, (operation) => {
if (controller.signal.aborted) return Promise.resolve(void 0);
const active = run(operation);
pending = active;
return active.finally(() => {
if (pending === active) pending = void 0;
if (controller.signal.aborted) unregister();
});
}, cancel);
},
/** Report the last observation without opening or querying SQLite. */
readHealth() {
const database = cachedDatabases.get(path.resolve(resolveOpenClawStateSqlitePath()));
return database?.db.isOpen ? database.walMaintenance.health : void 0;
}
};
}
//#endregion
//#region src/state/openclaw-state-db-handle.ts
function openTrackedStateDatabase(pathname, options) {
const result = openTrackedStateDatabaseResult(pathname, options);
if (result.status === "unavailable") throw result.error;
return result.database;
}
/** Native open failure is an ordinary read failure; admitted handles retain their own cleanup. */
function openTrackedStateDatabaseResult(pathname, options) {
assertStateDatabaseAccessAllowed(pathname);
try {
if (options?.expectedIdentity !== void 0) assertExistingDatabaseIdentity(pathname, options.expectedIdentity);
const location = options?.existingOnly || options?.expectedIdentity !== void 0 ? resolveExistingSqliteFileUri(pathname) : pathname;
const nativeOptions = options?.readOnly ? {
readOnly: true,
timeout: options.timeout
} : { enableForeignKeyConstraints: options?.enableForeignKeyConstraints };
const database = withSqliteNativeOpen(() => openNodeSqliteDatabase(location, nativeOptions));
try {
assertStateDatabaseAccessAllowed(pathname);
} catch (error) {
database.close();
throw error;
}
return {
status: "available",
database
};
} catch (error) {
return {
status: "unavailable",
error
};
}
}
function closeTrackedStateDatabase(database) {
if (database.isOpen) database.close();
}
//#endregion
//#region src/state/openclaw-state-db-failure.ts
const failurePaths = resolveGlobalSingleton(Symbol.for("openclaw.stateDatabaseFailurePaths"), () => /* @__PURE__ */ new WeakMap());
/** Preserve the terminal admission owner's path through worker error transport. */
function markOpenClawStateDatabaseFailure(error, pathname) {
failurePaths.set(error, pathname);
}
/** Cleanup aggregates must retain the original refusal without attributing unrelated errors. */
function findOpenClawStateDatabaseFailure(error, pathname) {
const pending = [error];
const seen = /* @__PURE__ */ new Set();
for (const current of pending) {
if (!(current instanceof Error) || seen.has(current)) continue;
seen.add(current);
if (failurePaths.get(current) === pathname) return current;
pending.push(current.cause);
if (current instanceof AggregateError) pending.push(...current.errors);
}
}
var OpenClawStateDatabaseSchemaMigrationRequiredError = class extends StartupMaintenanceRequiredError {
constructor(kind, pathname) {
super(kind, `OpenClaw state database schema migration required (${kind}) at ${pathname}; run openclaw doctor --fix to migrate it.`);
this.kind = kind;
this.pathname = pathname;
this.name = "OpenClawStateDatabaseSchemaMigrationRequiredError";
}
};
/** Runtime readers report malformed legacy state without entering repair mode. */
function normalizeOpenClawStateSchemaReadError(error, pathname) {
if (error instanceof Error && error.message.startsWith(`malformed database schema (idx_skill_workshop_collection_reviews_workspace_time)`)) {
const required = new OpenClawStateDatabaseSchemaMigrationRequiredError("legacy-workshop-review-index", pathname);
required.cause = error;
return required;
}
return error;
}
//#endregion
//#region src/state/openclaw-state-db-schema-version.ts
const CONTENT_VERSION_KEY = "state.schema.contentVersion";
const contentVersions = /* @__PURE__ */ new WeakMap();
const contentVersionQueries = /* @__PURE__ */ new WeakMap();
/** Content and its marker commit together, even while older readers retain their version floor. */
function readStateSchemaContentVersion(db) {
const schema = getAdmittedSqliteSchemaFacts(db);
const cached = schema && contentVersions.get(schema);
if (cached !== void 0) return cached;
const version = readContentVersion(db, schema?.userVersion ?? readSqliteUserVersion(db));
if (schema) contentVersions.set(schema, version);
return version;
}
function readContentVersion(db, published) {
if (!tableExists(db, "config_machine_state")) return published;
let query = contentVersionQueries.get(db);
if (!query) {
query = prepareSqliteQuerySync(db, () => getNodeSqliteKysely(db).selectFrom("config_machine_state").select("value_json").where("state_key", "=", CONTENT_VERSION_KEY));
contentVersionQueries.set(db, query);
}
const row = query().rows[0];
if (!row) return published;
let contentVersion;
try {
contentVersion = JSON.parse(row.value_json);
} catch (cause) {
throw new SqliteSchemaMismatchError(`Invalid shared state schema content version in ${CONTENT_VERSION_KEY}.`, { cause });
}
if (typeof contentVersion !== "number" || !Number.isSafeInteger(contentVersion) || contentVersion < 0) throw new SqliteSchemaMismatchError(`Invalid shared state schema content version in ${CONTENT_VERSION_KEY}.`);
return Math.max(published, contentVersion);
}
/** Cold migration planning checks physical content; admission still uses the recorded version. */
function readStateSchemaMigrationVersion(db) {
const version = readStateSchemaContentVersion(db);
if (version !== 16) return version;
const reviewWorkspace = tableHasColumn(db, "skill_workshop_collection_reviews", "workspace_dir");
const proposalWorkspace = tableHasColumn(db, "skill_workshop_proposals", "workspace_dir");
const releasedClaim = tableHasColumn(db, "skill_workshop_proposals", "claim_released_time");
if (!reviewWorkspace && !proposalWorkspace && !releasedClaim) return version;
const missingAttribution = reviewWorkspace && !proposalWorkspace;
const issues = collectSqliteSchemaIssues(db, `
CREATE TABLE skill_workshop_collection_reviews (
review_id TEXT NOT NULL PRIMARY KEY,
${reviewWorkspace ? "workspace_dir" : "owner_agent_id"} TEXT NOT NULL,
backup_id TEXT NOT NULL,
create_time INTEGER NOT NULL,
kept_names_json TEXT NOT NULL,
written_names_json TEXT NOT NULL,
dropped_json TEXT NOT NULL
) STRICT;
CREATE TABLE skill_workshop_proposals (
proposal_id TEXT NOT NULL PRIMARY KEY,
record_json TEXT NOT NULL,
owner_agent_id TEXT,
${proposalWorkspace ? "workspace_dir TEXT NOT NULL," : ""}
kind TEXT NOT NULL CHECK (kind IN ('create', 'update')),
status TEXT NOT NULL CHECK (status IN ('pending', 'applied', 'rejected', 'quarantined', 'stale')),
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL,
draft_hash TEXT NOT NULL,
origin_agent_id TEXT,
origin_session_key TEXT,
origin_run_id TEXT,
origin_message_id TEXT,
applied_at TEXT,
rejected_at TEXT,
quarantined_at TEXT,
stale_at TEXT,
status_reason TEXT
${releasedClaim ? ", claim_released_time INTEGER" : ""}
) STRICT;
`, {
allowedMissingTables: ["skill_workshop_collection_reviews"],
allowedColumnDefinitions: {
"skill_workshop_collection_reviews.workspace_dir": ["workspace_dir TEXT NOT NULL DEFAULT ''"],
"skill_workshop_proposals.workspace_dir": ["workspace_dir TEXT NOT NULL DEFAULT ''"]
}
});
if (!missingAttribution && issues.length === 0) return 15;
throw new SqliteSchemaMismatchError("Unrecognized Skill Workshop ownership schema; cannot apply the schema 16 migration.");
}
function assertSupportedStateSchemaVersion(db, pathname) {
try {
const userVersion = getAdmittedSqliteSchemaFacts(db)?.userVersion ?? readSqliteUserVersion(db);
const contentVersion = userVersion > 19 ? userVersion : readStateSchemaContentVersion(db);
if (contentVersion > 19) throw createNewerSqliteSchemaVersionError("OpenClaw state database", pathname, contentVersion, 19);
return userVersion;
} catch (error) {
throw normalizeOpenClawStateSchemaReadError(error, pathname);
}
}
//#endregion
//#region src/state/openclaw-state-db-runtime-failure.ts
/** Runtime validation uses the cache's existing handles, version counters, and terminal latch. */
function createOpenClawStateDatabaseRuntimeFailureOwner(owner) {
return {
closeTerminalFailure(pathname, error) {
markOpenClawStateDatabaseFailure(error, pathname);
owner.invalidate(pathname);
const cached = owner.cachedDatabases.get(pathname);
const errors = [];
try {
if (cached) owner.evict(cached);
} catch (cleanupError) {
errors.push(cleanupError);
}
try {
owner.notifyTerminalFailure(pathname, error);
} catch (notificationError) {
errors.push(notificationError);
}
throwSqliteLifecycleErrors(errors, "Terminal shared-state failure cleanup failed");
},
get: (pathname) => {
const resolvedPath = path.resolve(pathname);
const latched = owner.latch.get(resolvedPath);
if (latched) return latched;
const cached = owner.cachedDatabases.get(resolvedPath);
if (!cached?.db.isOpen) return;
try {
assertSupportedStateSchemaVersion(cached.db, resolvedPath);
return;
} catch (error) {
const failure = error instanceof Error ? error : new Error(String(error));
if (isSqliteCorruptionError(failure)) {
owner.evict(cached);
return;
}
if (isSqliteSchemaVersionError(failure)) owner.recordSchemaFailure(resolvedPath, failure);
return failure;
}
}
};
}
//#endregion
//#region src/infra/windows-private-directory.ts
const require = createRequire(import.meta.url);
let creators;
function loadPrivatePathCreators() {
const koffi = require("koffi");
const kernel32 = koffi.load("kernel32.dll");
const advapi32 = koffi.load("advapi32.dll");
const attributes = koffi.struct({
length: "uint32_t",
descriptor: "void *",
inheritHandle: "int32_t"
});
const getLastError = kernel32.func("uint32_t __stdcall GetLastError()");
const getCurrentProcess = kernel32.func("void * __stdcall GetCurrentProcess()");
const closeHandle = kernel32.func("int32_t __stdcall CloseHandle(void *handle)");
const localFree = kernel32.func("void * __stdcall LocalFree(void *memory)");
const openToken = advapi32.func("int32_t __stdcall OpenProcessToken(void *process, uint32_t access, _Out_ void **token)");
const getTokenInformation = advapi32.func("int32_t __stdcall GetTokenInformation(void *token, int32_t informationClass, _Out_ void *information, uint32_t length, _Out_ uint32_t *required)");
const convertSid = advapi32.func("int32_t __stdcall ConvertSidToStringSidW(void *sid, _Out_ void **text)");
const convertDescriptor = advapi32.func("int32_t __stdcall ConvertStringSecurityDescriptorToSecurityDescriptorW(str16 text, uint32_t revision, _Out_ void **descriptor, void *size)");
const createDirectory = kernel32.func("__stdcall", "CreateDirectoryW", "int32_t", ["str16", koffi.pointer(attributes)]);
const createFile = kernel32.func("__stdcall", "CreateFileW", "void *", [
"str16",
"uint32_t",
"uint32_t",
koffi.pointer(attributes),
"uint32_t",
"uint32_t",
"void *"
]);
const failure = (operation) => {
const errorCode = getLastError();
return Object.assign(/* @__PURE__ */ new Error(`${operation} failed (Win32 error ${errorCode})`), {
code: errorCode === 80 || errorCode === 183 ? "EEXIST" : "EIO",
errno: errorCode
});
};
const withPrivateAttributes = (inherit, operation) => {
const token = [null];
const sidText = [null];
const descriptor = [null];
if (!openToken(getCurrentProcess(), 8, token)) throw failure("OpenProcessToken");
try {
const required = [0];
getTokenInformation(token[0], 1, null, 0, required);
if (getLastError() !== 122 || required[0] === 0) throw failure("GetTokenInformation(size)");
const user = Buffer.alloc(required[0]);
if (!getTokenInformation(token[0], 1, user, user.length, required)) throw failure("GetTokenInformation");
if (!convertSid(koffi.decode(user, "void *"), sidText)) throw failure("ConvertSidToStringSidW");
const sid = koffi.decode(sidText[0], "char16_t", -1);
const flags = inherit ? "OICI" : "";
const sddl = `O:${sid}D:P(A;${flags};FA;;;${sid})(A;${flags};FA;;;SY)(A;${flags};FA;;;BA)`;
if (!convertDescriptor(sddl, 1, descriptor, null)) throw failure("ConvertStringSecurityDescriptorToSecurityDescriptorW");
return operation({
length: koffi.sizeof(attributes),
descriptor: descriptor[0],
inheritHandle: 0
});
} finally {
if (descriptor[0] !== null) localFree(descriptor[0]);
if (sidText[0] !== null) localFree(sidText[0]);
closeHandle(token[0]);
}
};
return {
directory: (directoryPath) => withPrivateAttributes(true, (security) => {
if (!createDirectory(path.toNamespacedPath(path.resolve(directoryPath)), security)) throw failure(`CreateDirectoryW(${directoryPath})`);
}),
file: (filePath) => withPrivateAttributes(false, (security) => {
const resolved = path.toNamespacedPath(path.resolve(filePath));
const handle = createFile(resolved, 3221225472, 3, security, 1, 128, null);
if (handle === null || BigInt.asIntN(64, koffi.address(handle)) === -1n) throw failure(`CreateFileW(${filePath})`);
try {
return fsSync.openSync(resolved, fsSync.constants.O_RDWR | (fsSync.constants.O_NOFOLLOW ?? 0));
} finally {
closeHandle(handle);
}
})
};
}
function createPrivateWindowsDirectory(directoryPath) {
creators ??= loadPrivatePathCreators();
creators.directory(directoryPath);
}
//#endregion
//#region src/infra/sqlite-private-directory.ts
function resolvePrivateSqliteSnapshotStagingRoot(env = process.env) {
const appData = process.platform === "win32" ? env.LOCALAPPDATA?.trim() : void 0;
const defaultRoot = process.platform === "win32" ? "AppData/Local" : ".cache";
const platformRoot = process.platform === "darwin" ? "Library/Caches" : defaultRoot;
const cacheRoot = [env.XDG_CACHE_HOME?.trim(), appData].find((root) => root && path.isAbsolute(root)) ?? path.join(resolveRequiredOsHomeDir(env), platformRoot);
return resolvePreferredOpenClawTmpDir({
preferredDir: path.join(cacheRoot, "openclaw"),
tmpdir: () => cacheRoot
});
}
function createPrivateSqliteTempDirectorySync(rootPath, prefix) {
if (process.platform !== "win32") return fsSync.mkdtempSync(path.join(rootPath, prefix));
const directoryPath = path.join(rootPath, `${prefix}${randomUUID()}`);
createPrivateWindowsDirectory(directoryPath);
return directoryPath;
}
//#endregion
//#region src/infra/sqlite-staging-token.ts
const SQLITE_STAGING_TOKEN_FILES = [
"owner.sqlite",
"owner.sqlite-journal",
"owner.sqlite-wal",
"owner.sqlite-shm"
];
var SqliteStagingRetiredError = class extends Error {
constructor() {
super("SQLite snapshot parent retired; aborting snapshot allocation");
}
};
/** Native transactions fence private staging admission and committed retirement. */
function acquireSqliteStagingToken(directory, mode, options = {}) {
const location = path.join(directory, SQLITE_STAGING_TOKEN_FILES[0]);
const readIdentity = (pathname, kind) => {
const stat = fsSync.lstatSync(pathname, { bigint: true });
if (!(kind === "directory" ? stat.isDirectory() : stat.isFile()) || process.platform === "win32" && (stat.dev === 0n || stat.ino === 0n)) throw new Error("SQLite staging ownership is unknown");
return stat;
};
const directoryIdentity = readIdentity(directory, "directory");
const family = SQLITE_STAGING_TOKEN_FILES.map((file) => fsSync.lstatSync(path.join(directory, file), { throwIfNoEntry: false }));
const existing = family[0];
if (family.some((file) => file && (!file.isFile() || process.getuid && file.uid !== process.getuid())) || !existing && mode !== "create" && !options.allowMissing) throw new Error("SQLite snapshot token ownership is unknown");
const existingIdentity = existing ? readIdentity(location, "file") : void 0;
const db = withSqliteNativeOpen(() => openNodeSqliteDatabase(existing ? resolveExistingSqliteFileUri(location) : location));
let tokenIdentity;
const kysely = getNodeSqliteKysely(db);
const execute = (statement) => executeSqliteQueryTakeFirstSync(db, { compile: () => statement.compile(kysely) });
let exclusive = mode === "reclaim";
let retired = false;
const assertIdentity = () => {
const currentDirectory = readIdentity(directory, "directory");
if (directoryIdentity.dev !== currentDirectory.dev || directoryIdentity.ino !== currentDirectory.ino) throw new Error("SQLite staging ownership changed before retirement");
const currentToken = readIdentity(location, "file");
if (tokenIdentity.dev !== currentToken.dev || tokenIdentity.ino !== currentToken.ino) throw new Error("SQLite staging ownership changed before retirement");
};
const readVersion = () => {
const row = execute(sql`PRAGMA user_version`);
return isRecord(row) ? row.user_version : void 0;
};
const beginRetirement = () => {
assertIdentity();
if (!db.isOpen) return acquireSqliteStagingToken(directory, "reclaim");
if (!db.isTransaction || !exclusive) {
if (db.isTransaction) execute(sql`ROLLBACK`);
execute(sql`BEGIN EXCLUSIVE`);
exclusive = true;
}
assertIdentity();
const version = readVersion();
if (version !== (retired ? 1 : 0)) {
retired = version === 1;
throw new SqliteStagingRetiredError();
}
return token;
};
const release = (retiring = false) => {
if (!db.isOpen) return;
if (retiring) {
beginRetirement();
if (!retired) execute(sql`PRAGMA user_version=1`);
execute(sql`COMMIT`);
retired = true;
} else if (db.isTransaction) execute(sql`ROLLBACK`);
db.close();
};
const token = Object.assign(release, { beginRetirement });
try {
tokenIdentity = existingIdentity ?? readIdentity(location, "file");
execute(sql`PRAGMA busy_timeout=0`);
if (mode === "create") execute(sql`BEGIN IMMEDIATE`);
else if (mode === "reclaim") execute(sql`BEGIN EXCLUSIVE`);
else {
execute(sql`BEGIN`);
execute(sql`SELECT rootpage FROM sqlite_schema LIMIT 1`);
}
const journalMode = execute(sql`PRAGMA journal_mode`);
if (!isRecord(journalMode) || journalMode.journal_mode !== "delete") throw new Error("SQLite snapshot token journal mode is unknown");
const version = readVersion();
if (version !== 0 && (mode !== "reclaim" || version !== 1)) throw new SqliteStagingRetiredError();
retired = version === 1;
assertIdentity();
return token;
} catch (error) {
release();
throw error;
}
}
//#endregion
//#region src/infra/sqlite-snapshot-retirement.ts
const SQLITE_SNAPSHOT_PREFIX = "openclaw-sqlite-readonly-v2-";
const suffix = "(?:[A-Za-z0-9]{6}|[\\da-f]{8}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{12})$";
const SQLITE_SNAPSHOT_LEGACY_MARKER = new RegExp(`^openclaw-sqlite-readonly-[1-9]\\d*-${suffix}`, "u");
const tokenMarker = new RegExp(`^${SQLITE_SNAPSHOT_PREFIX}${suffix}`, "u");
const SQLITE_SNAPSHOT_LEGACY_AGE_MS = 864e5;
const pendingTokenReleases = /* @__PURE__ */ new Map();
function releaseTokens(directory, tokens) {
const pending = pendingTokenReleases.get(directory) ?? /* @__PURE__ */ new Set();
const failures = [];
for (const token of tokens) try {
token();
pending.delete(token);
} catch (error) {
pending.add(token);
failures.push(error);
}
if (pending.size) pendingTokenReleases.set(directory, pending);
else pendingTokenReleases.delete(directory);
if (failures.length) throw new AggregateError(failures, "SQLite snapshot retirement token release failed");
}
/** A failed native close retains its actual handle until retry, even after commit or unlink. */
function drainPendingSqliteSnapshotTokens(directory) {
releaseTokens(directory, pendingTokenReleases.get(directory) ?? []);
}
const isSqliteSnapshotStagingName = (name) => SQLITE_SNAPSHOT_LEGACY_MARKER.test(name) || tokenMarker.test(name);
function acquireSqliteSnapshotToken(directory, mode) {
return acquireSqliteStagingToken(directory, mode, { allowMissing: SQLITE_SNAPSHOT_LEGACY_MARKER.test(path.basename(directory)) });
}
/** Hold every nested lifetime before selecting payload; a parent lock alone cannot fence children. */
function beginSqliteSnapshotRetirement(directory, options = {}) {
drainPendingSqliteSnapshotTokens(directory);
const tokens = [];
const payload = [];
const release = () => releaseTokens(directory, tokens.filter((token) => token !== options.token));
if (!fsSync.existsSync(directory)) {
options.token?.();
return {
bytes: 0,
payload,
release,
retire: () => {}
};
}
function inspect(current, inheritedCutoff, layout = "", lock = true, parentFenced = false) {
const stat = fsSync.lstatSync(current);
if (!stat.isDirectory() || process.getuid && stat.uid !== process.getuid()) throw new Error("Snapshot directory ownership is unknown");
const legacy = !layout && SQLITE_SNAPSHOT_LEGACY_MARKER.test(path.basename(current));
const cutoff = options.cutoff !== void 0 && legacy ? Math.min(inheritedCutoff, Date.now() - SQLITE_SNAPSHOT_LEGACY_AGE_MS) : inheritedCutoff;
if (legacy && lock && options.cutoff !== void 0) inspect(current, cutoff, layout, false);
if (!layout && lock) {
const unfinishedAllocation = parentFenced && tokenMarker.test(path.basename(current)) && fsSync.readdirSync(current).length === 0;
tokens.push(current === directory && options.token ? options.token.beginRetirement() : unfinishedAllocation ? acquireSqliteStagingToken(current, "reclaim", { allowMissing: true }) : acquireSqliteSnapshotToken(current, "reclaim"));
}
let bytes = 0;
let newest = stat.mtimeMs;
for (const entry of fsSync.readdirSync(current, { withFileTypes: true })) {
const location = path.join(current, entry.name);
const item = fsSync.lstatSync(location);
if (process.getuid && item.uid !== process.getuid()) throw new Error("Snapshot file ownership is unknown");
if ((!layout || options.cutoff === void 0) && item.isFile() && SQLITE_STAGING_TOKEN_FILES.some((file) => file === entry.name)) continue;
newest = Math.max(newest, item.mtimeMs);
if (item.isDirectory()) {
const nested = isSqliteSnapshotStagingName(entry.name);
const childLayout = nested ? "" : [layout, entry.name].filter(Boolean).join("/");
if (options.cutoff !== void 0 && (!nested && ![
"openclaw",
"openclaw-state",
"openclaw-state/state"
].includes(childLayout) || nested && layout !== "" && layout !== "openclaw")) throw new Error("Unrecognized snapshot directory");
const allocationParent = layout === "openclaw" ? path.dirname(current) : current;
const child = inspect(location, cutoff, childLayout, lock, nested && (layout === "" || layout === "openclaw") && isSqliteSnapshotStagingName(path.basename(allocationParent)));
bytes += child.bytes;
newest = Math.max(newest, child.newest);
} else if (options.cutoff === void 0 || item.isFile() && (layout === "openclaw-state/state" ? /^openclaw\.sqlite(?:-wal|-shm|-journal)?$/u.test(entry.name) : !layout && /^(?:first|database\.sqlite(?:\.partial)?(?:-wal|-shm|-journal)?)$/u.test(entry.name))) {
bytes += item.size;
if (lock) payload.push(location);
} else throw new Error("Unrecognized snapshot artifact");
}
if (newest >= cutoff) throw new Error(legacy ? "Legacy snapshot contains activity newer than 24 hours" : "Snapshot contains activity within the reclamation grace period");
return {
bytes,
newest
};
}
try {
const { bytes } = inspect(directory, options.cutoff ?? Number.POSITIVE_INFINITY);
return {
bytes,
payload,
release,
retire: () => {
for (const token of tokens) token(true);
}
};
} catch (error) {
release();
throw error;
}
}
//#endregion
//#region src/infra/sqlite-readonly-location-cleanup.ts
var SqliteSnapshotCleanupError = class extends Error {};
const pendingTempDirectoryCleanup = /* @__PURE__ */ new Map();
let cleanupExitHandlerInstalled = false;
const activeSnapshotWork = /* @__PURE__ */ new Map();
let pendingSignalCleanup;
function snapshotDirectory(directory) {
let owner = pendingTempDirectoryCleanup.get(directory);
if (!owner) {
owner = { readers: /* @__PURE__ */ new Set() };
pendingTempDirectoryCleanup.set(directory, owner);
}
return owner;
}
function cleanupSnapshotOperations() {
pendingSignalCleanup ??= (async () => {
const directories = pendingTempDirectoryCleanup.keys();
while (true) {
while (activeSnapshotWork.size > 0) {
for (const stop of activeSnapshotWork.values()) stop();
await Promise.allSettled(activeSnapshotWork.keys());
}
const next = directories.next();
if (next.done) break;
const directory = next.value;
await removeTempDirectoryAsync(directory, (error) => emitSnapshotCleanupFailure({
cleanupRoot: directory,
operation: "rm",
code: extractErrorCode(error)
}));
}
})().finally(() => {
pendingSignalCleanup = void 0;
});
return pendingSignalCleanup;
}
/** Join native backup work or a terminated child before removing its private bytes. */
function retainSnapshotWork(work, stop = () => {}) {
registerSignalExitFinalizer(cleanupSnapshotOperations);
activeSnapshotWork.set(work, stop);
const release = () => activeSnapshotWork.delete(work);
work.then(release, release);
return work;
}
function registerSnapshotTempDirectory(directory, release) {
const owner = snapshotDirectory(directory);
owner.release = release ?? owner.release;
if (!cleanupExitHandlerInstalled) {
cleanupExitHandlerInstalled = true;
process.once("exit", () => {
for (const stop of activeSnapshotWork.values()) stop();
if (activeSnapshotWork.size === 0) for (const pendingDir of pendingTempDirectoryCleanup.keys()) removeTempDirectory(pendingDir);
});
}
registerSignalExitFinalizer(cleanupSnapshotOperations);
}
const tempDirectoryRemovalOptions = {
force: true,
maxRetries: 3,
recursive: true,
retryDelay: 20
};
function emitSnapshotCleanupFailure(report, onCleanupFailure) {
if (onCleanupFailure) try {
onCleanupFailure(report);
return;
} catch {}
try {
getChildLogger({ subsystem: "infra/sqlite-snapshot" }).warn({
path: report.cleanupRoot,
operation: report.operation,
errorCode: report.code
}, "SQLite read-only snapshot cleanup failed. Check directory permissions and available storage before retrying.");
} catch {}
}
function assertSnapshotReadersRetired(owner) {
if (owner?.readers.size) throw new SqliteSnapshotCleanupError("SQLite snapshot still belongs to an active reader");
}
function prepareSnapshotRetirement(directory) {
drainPendingSqliteSnapshotTokens(directory);
const owner = pendingTempDirectoryCleanup.get(directory);
assertSnapshotReadersRetired(owner);
if (owner?.releaseAsync) throw new SqliteSnapshotCleanupError("SQLite snapshot requires asynchronous cleanup");
if (owner?.retired || !owner?.release && !fsSync.existsSync(path.join(directory, SQLITE_STAGING_TOKEN_FILES[0]))) return;
if (owner) owner.retirementStarted = true;
return beginSqliteSnapshotRetirement(directory, { token: owner?.release });
}
/** Delete in the token process: owner death must stop unlinking when its locks disappear. */
function retireSqliteSnapshotPayload(retirement) {
for (const file of retirement.payload) fsSync.rmSync(file, tempDirectoryRemovalOptions);
retirement.retire();
}
function removeTempDirectory(tempDir, onFailure) {
try {
const retirement = prepareSnapshotRetirement(tempDir);
try {
if (retirement) {
retireSqliteSnapshotPayload(retirement);
const owner = snapshotDirectory(tempDir);
owner.release = void 0;
owner.retired = true;
}
fsSync.rmSync(tempDir, tempDirectoryRemovalOptions);
} finally {
retirement?.release();
}
pendingTempDirectoryCleanup.delete(tempDir);
return true;
} catch (error) {
onFailure?.(error);
registerSnapshotTempDirectory(tempDir);
return false;
}
}
async function removeTempDirectoryAsync(tempDir, onFailure) {
try {
const owner = pendingTempDirectoryCleanup.get(tempDir);
assertSnapshotReadersRetired(owner);
if (owner?.releaseAsync) {
owner.retirementStarted = true;
await (owner.retiring ??= owner.releaseAsync().then(() => {
owner.releaseAsync = void 0;
owner.retired = true;
}).finally(() => {
owner.retiring = void 0;
}));
}
const retirement = prepareSnapshotRetirement(tempDir);
try {
for (const file of retirement?.payload ?? []) await retainSnapshotWork(fsSync.promises.rm(file, tempDirectoryRemovalOptions));
if (retirement) {
retirement.retire();
const current = snapshotDirectory(tempDir);
current.release = void 0;
current.retired = true;
}
await retainSnapshotWork(fsSync.promises.rm(tempDir, tempDirectoryRemovalOptions));
} finally {
retirement?.release();
}
pendingTempDirectoryCleanup.delete(tempDir);
return true;
} catch (error) {
onFailure?.(error);
registerSnapshotTempDirectory(tempDir);
return false;
}
}
function adoptPreparedLocation(location, ownedRoot, requireCleanup = false, onCleanupFailure) {
const tempDir = ownedRoot ?? path.dirname(location);
registerSnapshotTempDirectory(tempDir);
let active = true;
let pending;
let reported = false;
const reportFailure = (error) => {
if (!requireCleanup && !reported) {
reported = true;
emitSnapshotCleanupFailure({
cleanupRoot: tempDir,
operation: "rm",
code: extractErrorCode(error)
}, onCleanupFailure);
}
};
const complete = (removed) => {
if (removed) active = false;
else if (requireCleanup) throw new Error(`SQLite read-only worker snapshot cleanup failed: ${tempDir}`);
return removed;
};
return {
location,
cleanupRoot: tempDir,
cleanup: () => {
if (pending) return requireCleanup ? complete(false) : false;
if (!active) return true;
return complete(removeTempDirectory(tempDir, reportFailure));
},
cleanupAsync: () => {
if (pending) return pending;
if (!active) return Promise.resolve(true);
pending = Promise.resolve().then(() => removeTempDirectoryAsync(tempDir, reportFailure)).then(complete).finally(() => {
pending = void 0;
});
return pending;
}
};
}
//#endregion
//#region src/infra/sqlite-snapshot-staging.ts
function stagingParent(root) {
const parent = path.basename(root) === "openclaw" ? path.dirname(root) : root;
return isSqliteSnapshotStagingName(path.basename(parent)) ? parent : void 0;
}
/** A private reader protects its bytes independently of the staging child. */
function acquireSqliteSnapshotReadToken(directory) {
return acquireSqliteSnapshotToken(directory, "read");
}
function sqliteSnapshotStagingError(tempDir, cause, allocation = false) {
markSqliteInspectionOperation(cause, "snapshot");
let destination = allocation;
let capacity = false;
let sqliteErrcode;
for (let depth = 0, error = cause; depth < 8 && error instanceof Error; depth += 1) {
const { code, errcode, path: errorPath } = error;
capacity ||= ["ENOSPC", "EDQUOT"].includes(code ?? "") || errcode === 13;
if (capacity || typeof errcode === "number" && [
13,
778,
1034,
1290
].includes(errcode) || `${errorPath ?? ""}${path.sep}`.startsWith(`${tempDir}${path.sep}`)) {
destination = true;
if (typeof errcode === "number") sqliteErrcode = errcode;
}
error = error.cause;
}
if (!destination) return cause;
const guidance = capacity ? "free disk space/quota" : "check filesystem health and write permissions";
const message = `${cause instanceof Error ? cause.message : String(cause)}${sqliteErrcode !== void 0 ? ` (SQLite errcode=${sqliteErrcode})` : ""}; snapshot staging root ${allocation ? tempDir : path.dirname(tempDir)}: ${guidance} or set XDG_CACHE_HOME to a writable filesystem`;
return new Error(message, { cause });
}
function createSqliteSnapshotStagingDirectorySync(root = resolvePrivateSqliteSnapshotStagingRoot(), allowLegacyWorker = false) {
const owned = createSqliteSnapshotStagingTokenSync(root, allowLegacyWorker);
registerSnapshotTempDirectory(owned.directory, owned.release);
return owned.directory;
}
/** Token workers remove disposable payload under their own native retirement fences. */
function createSqliteSnapshotStagingTokenSync(root = resolvePrivateSqliteSnapshotStagingRoot(), allowLegacyWorker = false) {
const parentDirectory = stagingParent(root);
const parent = parentDirectory ? acquireSqliteSnapshotToken(parentDirectory, "read") : void 0;
let directory;
try {
try {
directory = createPrivateSqliteTempDirectorySync(root, allowLegacyWorker ? `openclaw-sqlite-readonly-${process.pid}-` : SQLITE_SNAPSHOT_PREFIX);
} catch (error) {
throw sqliteSnapshotStagingError(root, error, true);
}
return {
directory,
release: acquireSqliteSnapshotToken(directory, "create")
};
} catch (error) {
if (directory) removeTempDirectory(directory);
throw error;
} finally {
parent?.();
}
}
Buffer.from([
217,
213,
5,
249,
32,
161,
99,
215
]);
resolveGlobalSingleton(Symbol.for("openclaw.sqliteSnapshotFlights"), () => /* @__PURE__ */ new Map());
//#endregion
//#region src/infra/sqlite-live-snapshot.ts
const liveOwners = resolveGlobalSingleton(Symbol.for("openclaw.sqliteLiveSnapshotOwners"), () => /* @__PURE__ */ new Map());
function registerLiveSqliteSnapshotOwner(options) {
const identity = readDatabasePathIdentitySync(options.databasePath);
const registration = {
assertCurrent: options.assertCurrent,
database: options.database,
owner: options.owner
};
liveOwners.set(identity.key, registration);
return () => {
if (liveOwners.get(identity.key) === registration) liveOwners.delete(identity.key);
};
}
//#endregion
//#region src/state/openclaw-state-db-snapshot-owner.ts
function createOpenClawStateSnapshotOwnerRegistry() {
const releases = /* @__PURE__ */ new WeakMap();
return {
register(database, getCurrent) {
releases.set(database.db, registerLiveSqliteSnapshotOwner({
database: database.db,
databasePath: database.path,
owner: "openclaw-state",
assertCurrent: () => {
if (getCurrent() !== database || !database.db.isOpen) throw new Error("OpenClaw state snapshot owner is no longer current");
}
}));
},
release(database) {
releases.get(database)?.();
releases.delete(database);
}
};
}
const openClawStateSnapshotOwners = resolveGlobalSingleton(Symbol.for("openclaw.stateSnapshotOwners"), createOpenClawStateSnapshotOwnerRegistry);
//#endregion
//#region src/state/openclaw-state-db-cache.ts
const stateDatabaseLifecycle = resolveGlobalSingleton(Symbol.for("openclaw.stateDatabaseLifecycle"), () => ({
cachedDatabases: /* @__PURE__ */ new Map(),
retainedDatabaseHandles: /* @__PURE__ */ new Map(),
idleTimers: /* @__PURE__ */ new WeakMap(),
idleReferences: /* @__PURE__ */ new WeakMap(),
unregisterRetainedExitClose: void 0,
databaseIdentities: /* @__PURE__ */ new WeakMap(),
borrowers: /* @__PURE__ */ new WeakMap(),
databaseLifecycleListeners: /* @__PURE__ */ new Set(),
terminalOpenLatch: createSqliteTerminalOpenLatch({ closeByPath: (pathname, error) => runtimeFailures.closeTerminalFailure(pathname, error) }),
asyncResources: createOpenClawStateDatabaseAsyncLifecycle()
}), () => closeOpenClawStateDatabaseAsync());
const { cachedDatabases, retainedDatabaseHandles, idleTimers, idleReferences, databaseIdentities, borrowers, databaseLifecycleListeners, terminalOpenLatch, asyncResources } = stateDatabaseLifecycle;
const { touch: touchStateDatabase, retain: retainOpenClawStateDatabaseForIdle } = createStateDatabaseIdleRetirement(stateDatabaseLifecycle, retireOpenClawStateDatabaseHandle);
const { register: registerStateDatabaseWalAdmission, readHealth: readOpenClawStateWalHealth } = createStateDatabaseWalOwner(stateDatabaseLifecycle, retainOpenClawStateDatabaseForIdle);
function notifyOpenClawStateDatabaseLifecycle(event) {
const notification = event.kind === "open-error" ? {
...event,
identity: event.identity ?? asyncResources.knownIdentity(event.path)
} : event;
for (const listener of databaseLifecycleListeners) listener(notification);
}
function notifyOpenClawStateDatabaseClosed(database) {
notifyOpenClawStateDatabaseLifecycle({
kind: "closed",
path: database.path,
identity: requireOpenClawStateDatabaseIdentity(database)
});
}
function requireOpenClawStateDatabaseIdentity(database) {
const identity = databaseIdentities.get(database.db);
if (!identity) throw new Error("Published shared-state owner has no recorded database identity");
return identity;
}
const runtimeFailures = createOpenClawStateDatabaseRuntimeFailureOwner({
cachedDatabases,
latch: terminalOpenLatch,
evict: evictCachedOpenClawStateDatabase,
invalidate: (pathname) => asyncResources.invalidate(pathname),
notifyTerminalFailure: (pathname, error) => notifyOpenClawStateDatabaseLifecycle({
kind: "terminal-failure",
path: pathname,
error,
identity: asyncResources.knownIdentity(pathname)
}),
recordSchemaFailure: (pathname, error) => {
terminalOpenLatch.record(pathname, error);
notifyOpenClawStateDatabaseLifecycle({
kind: "open-error",
path: pathname,
error
});
}
});
function registerOpenClawStateDatabaseLifecycleListener(listener) {
databaseLifecycleListeners.add(listener);
for (const database of cachedDatabases.values()) if (database.db.isOpen) listener({
kind: "opened",
database,
identity: requireOpenClawStateDatabaseIdentity(database)
});
return () => databaseLifecycleListeners.delete(listener);
}
function retainStateDatabaseClose(database) {
retainedDatabaseHandles.set(database.db, database);
stateDatabaseLifecycle.unregisterRetainedExitClose ??= registerSqliteCacheExitClose(closeOpenClawStateDatabase);
}
function ownMaintenanceStateDatabaseHandle(database) {
getOpenClawDatabaseMaintenanceScope()?.own(database.db, "shared-handles", async () => {
const closingScope = getOpenClawDatabaseMaintenanceScope();
if (!closingScope || !isOpenClawDatabaseMaintenanceResourceOwned(database.db, closingScope)) return;
if (cachedDatabases.get(database.path) === database || retainedDatabaseHandles.get(database.db) === database) {
await cancelSqliteWalWriteAdmission(database.db);
if (isOpenClawDatabaseMaintenanceResourceOwned(database.db, closingScope) && (cachedDatabases.get(database.path) === database || retainedDatabaseHandles.get(database.db) === database)) retireOpenClawStateDatabaseHandle(database, false);
}
});
}
function closeUnpublishedOpenClawStateDatabaseHandle(database) {
const errors = closeOpenClawStateDatabaseHandle(database);
if (retainedDatabaseHandles.get(database.db) === database) ownMaintenanceStateDatabaseHandle(database);
return errors;
}
/** Retain one exact canonical native owner; only the final reference retires its handle. */
const { retain: retainOpenClawStateDatabase, borrowForRead: borrowOpenClawStateDatabaseForAsyncRead, retainForIndependentRead: retainOpenClawStateDatabaseForIndependentRead } = createStateDatabaseRetainer(stateDatabaseLifecycle, {
assertOpen(pathname, ownership) {
assertOpenClawStateDatabaseOpenAllowed(pathname, ownership);
assertExistingOpenClawStateSchemaCacheAdmission(pathname, stateDatabaseLifecycle);
},
capture: (pathname) => asyncResources.capture(pathname),
retire: retireOpenClawStateDatabaseHandle,
retainFailed: retainStateDatabaseClose,
touch: touchStateDatabase
});
/** Close both physical-handle owners while retaining every cleanup failure. */
function closeOpenClawStateDatabaseHandle(database, options) {
clearTimeout(idleTimers.get(database.db));
idleTimers.delete(database.db);
try {
assertStateDatabaseBorrowersReleased(borrowers.get(database.db), database.path);
} catch (error) {
const owner = borrowers.get(database.db);
if (owner) {
owner.retiring = true;
owner.retirement = {
ordinary: true,
isCurrent: () => true,
retire: () => {
throwSqliteLifecycleErrors(closeOpenClawStateDatabaseHandle(database, options), `OpenClaw state database cleanup failed for ${database.path}.`);
owner.cleanupComplete = true;
borrowers.delete(database.db);
}
};
}
retainStateDatabaseClose(database);
return [error];
}
idleReferences.delete(database.db);
const errors = [];
openClawStateSnapshotOwners.release(database.db);
try {
cancelSqliteWalWriteAdmission(database.db);
database.walMaintenance?.close(options);
} catch (error) {
errors.push(error);
}
try {
clearNodeSqliteKyselyCacheForDatabase(database.db);
} catch (error) {
errors.push(error);
}
try {
closeTrackedStateDatabase(database.db);
} catch (error) {
errors.push(error);
}
let cleanupPending = false;
if (!database.db.isOpen) try {
database.afterClose?.();
} catch (error) {
errors.push(error);
cleanupPending = true;
}
if (database.db.isOpen || cleanupPending) retainStateDatabaseClose(database);
else retainedDatabaseHandles.delete(database.db);
if (cachedDatabases.get(database.path)?.db === database.db) cachedDatabases.delete(database.path);
if (retainedDatabaseHandles.size === 0) {
stateDatabaseLifecycle.unregisterRetainedExitClose?.();
stateDatabaseLifecycle.unregisterRetainedExitClose = void 0;
}
return errors;
}
function evictCachedOpenClawStateDatabase(database) {
if (cachedDatabases.get(database.path) !== database) return false;
asyncResources.invalidate(database.path);
cachedDatabases.delete(database.path);
notifyOpenClawStateDatabaseClosed(database);
closeOpenClawStateDatabaseHandle(database, { checkpointMode: "PASSIVE" });
return true;
}
/** Evict an exact cached shared-state owner after a proven corruption read. */
function evictOpenClawStateDatabaseAfterCorruption(database, error) {
return isSqliteCorruptionError(error) && evictCachedOpenClawStateDatabase(database);
}
/** Publish a fully opened handle and bind query corruption to its exact cache owner. */
function publishOpenClawStateDatabase(database, env) {
const { db, path: pathname } = database;
admitSqliteSchema(db);
assertSupportedStateSchemaVersion(db, pathname);
const { identity, admission } = asyncResources.publish(pathname);
databaseIdentities.set(db, identity);
cachedDatabases.set(pathname, database);
registerStateDatabaseWalAdmission(database, identity, admission, env);
touchStateDatabase(database);
openClawStateSnapshotOwners.register(database, () => cachedDatabases.get(pathname));
ownMaintenanceStateDatabaseHandle(database);
notifyOpenClawStateDatabaseLifecycle({
kind: "opened",
database,
identity
});
registerNodeSqliteKyselyQueryErrorHandler(db, (error) => {
if (!db.isTransaction && isSqliteCorruptionError(error)) evictCachedOpenClawStateDatabase(database);
});
terminalOpenLatch.clear(pathname);
return database;
}
function getCachedOpenClawStateDatabase(pathname, options) {
const maintenance = getOpenClawDatabaseMaintenanceScope();
if (options?.readOnly) maintenance?.assertReadAdmission();
else maintenance?.assertAdmission();
assertExistingOpenClawStateSchemaCacheAdmission(pathname, stateDatabaseLifecycle);
const runtimeFailure = runtimeFailures.get(pathname);
if (runtimeFailure) throw runtimeFailure;
const database = cachedDatabases.get(path.resolve(pathname));
if (database && borrowers.get(database.db)?.retiring) throw new Error(`OpenClaw state database native borrower cleanup is pending: ${pathname}`);
if (database) touchStateDatabase(database);
return database;
}
function getOpenClawStateDatabaseIfOpenAtPath(pathname) {
const cached = getCachedOpenClawStateDatabase(pathname);
observeOpenClawDatabaseMaintenanceResource(cached?.db.isOpen ? cached.db : void 0);
return cached?.db.isOpen ? cached : void 0;
}
/** Remove a closed cached owner while fresh-open access is held. */
function closeStaleCachedOpenClawStateDatabase(database) {
if (cachedDatabases.get(database.path) !== database) return;
asyncResources.invalidate(database.path);
const errors = closeOpenClawStateDatabaseHandle(database);
notifyOpenClawStateDatabaseClosed(database);
throwSqliteLifecycleErrors(errors, `Stale OpenClaw state database cleanup failed for ${database.path}.`);
}
/** Latch background verification damage so later opens fail without rescanning. */
function recordOpenClawStateDatabaseOpenFailure(pathname, error, generation) {
return terminalOpenLatch.record(pathname, error, generation);
}
/** Clear a terminal open failure after doctor rewrites the database file. */
function clearOpenClawStateDatabaseOpenFailure(pathname) {
const resolvedPath = path.resolve(pathname);
terminalOpenLatch.clear(resolvedPath);
asyncResources.invalidate(resolvedPath);
notifyOpenClawStateDatabaseLifecycle({
kind: "failure-cleared",
path: resolvedPath,
identity: asyncResources.knownIdentity(resolvedPath)
});
}
/** Validate the canonical terminal fact before acquiring a domain-operation lease. */
async function getOpenClawStateDatabaseTerminalFailureAsync(context) {
context.admission.assertCurrent();
const failure = await terminalOpenLatch.getAsync(context.admission.databasePath, async (_path, generation) => {
const { inspectOpenClawStateDatabase } = await import("./openclaw-state-worker-store-C-vikWR4.mjs");
const matches = await inspectOpenClawStateDatabase(context, {
type: "database.generationMatches",
input: { generation }
});
if (matches === void 0) throw new Error("Recorded shared-state database generation is unavailable");
return matches;
});
context.admission.assertCurrent();
return failure;
}
/** Reject shared-state access after a process-local terminal failure. */
function assertOpenClawStateDatabaseOpenAllowed(pathname, ownership) {
if (ownership === "cached-read") assertStateDatabaseReadAllowed(pathname);
else assertStateDatabaseAccessAllowed(pathname);
const { identity } = asyncResources.capture(pathname);
const terminalFailure = terminalOpenLatch.get(pathname);
if (terminalFailure) throw terminalFailure;
const resolvedPath = path.resolve(pathname);
for (const database of retainedDatabaseHandles.values()) if (borrowers.get(database.db)?.retiring && (database.path === resolvedPath || databaseIdentities.get(database.db)?.key === identity.key)) throw new Error(`OpenClaw state database native borrower cleanup is pending: ${pathname}`);
}
function recordOpenClawStateDatabaseLifecycleOpenError(pathname, error) {
notifyOpenClawStateDatabaseLifecycle({
kind: "open-error",
path: path.resolve(pathname),
error
});
}
/** Reject a fresh shared-state open after known corruption until repair clears it. */
function assertOpenClawStateDatabaseFreshOpenAllowedAtPath(pathname, env, onNativeCleanupFailure) {
assertOpenClawStateDatabaseOpenAllowed(pathname);
let quarantineFailure;
try {
quarantineFailure = readOpenClawDatabaseQuarantineFailure("state", pathname, { env });
} catch (error) {
if (!(error instanceof OpenClawQuarantineReadCleanupError)) throw error;
onNativeCleanupFailure?.(error);
return;
}
if (quarantineFailure?.cause instanceof OpenClawQuarantineReadCleanupError) onNativeCleanupFailure?.(quarantineFailure.cause);
if (quarantineFailure) {
runtimeFailures.closeTerminalFailure(pathname, quarantineFailure);
throw quarantineFailure;
}
}
/** SQLite owns checkpoint exclusion; retirement joins the actual native handle. */
function retireOpenClawStateDatabaseHandle(database, retireAdmission = true, options) {
assertStateDatabaseBorrowersReleased(borrowers.get(database.db), database.path);
const borrowedOwner = borrowers.get(database.db);
try {
const wasCached = cachedDatabases.get(database.path)?.db === database.db;
if (retireAdmission) asyncResources.invalidate(database.path);
const errors = closeOpenClawStateDatabaseHandle(database, options);
if (wasCached && retireAdmission) try {
notifyOpenClawStateDatabaseClosed(database);
} catch (error) {
errors.push(error);
}
throwSqliteLifecycleErrors(errors, `OpenClaw state database cleanup failed for ${database.path}.`);
} catch (error) {
if (borrowedOwner) retainStateDatabaseClose(database);
throw error;
}
if (borrowedOwner) {
borrowedOwner.cleanupComplete = true;
borrowers.delete(database.db);
}
}
/** Close cached and disposal-only handles, preserving independent cleanup failures. */
function retireOpenClawStateDatabaseHandles(pathname, options, identity) {
const databases = /* @__PURE__ */ new Set([...retainedDatabaseHandles.values(), ...cachedDatabases.values()]);
const errors = [];
let found = false;
for (const database of databases) {
if (pathname !== void 0 && database.path !== pathname && (identity === void 0 || databaseIdentities.get(database.db)?.key !== identity.key)) continue;
found = true;
try {
retireOpenClawStateDatabaseHandle(database, true, options);
} catch (error) {
errors.push(error);
}
}
throwSqliteLifecycleErrors(errors, "OpenClaw state database cleanup failed.");
return found;
}
/** Close one cached shared state database handle by exact pathname. */
function closeOpenClawStateDatabaseByPath(pathname, options) {
return retireOpenClawStateDatabaseHandles(path.resolve(pathname), options, asyncResources.identity(pathname));
}
/** Close all cached shared state database handles. */
function closeOpenClawStateDatabase(options) {
retireOpenClawStateDatabaseHandles(void 0, options);
}
/** Register a resource owner before it can admit any shared-state worker opens. */
function registerOpenClawStateDatabaseAsyncResource(resource) {
return asyncResources.register(resource);
}
/** Capture the canonical read generation before any asynchronous worker admission. */
const captureOpenClawStateDatabaseReadAdmission = asyncResources.capture;
/** Bind worker-created storage to its captured admission without publishing a native handle. */
function publishOpenClawStateDatabaseWorkerAdmission(admission) {
admission.assertCurrent();
asyncResources.publish(admission.databasePath);
admission.assertCurrent();
}
/** Orderly lifecycle close; synchronous close remains native/exit cleanup only. */
async function closeOpenClawStateDatabaseAsync(options) {
await asyncResources.close(void 0, () => retireOpenClawStateDatabaseHandles(void 0, options));
}
/** Test whether a cached shared state database handle is still open, optionally at one path. */
function isOpenClawStateDatabaseOpen(pathname) {
if (pathname !== void 0) return cachedDatabases.get(path.resolve(pathname))?.db.isOpen === true;
return Array.from(cachedDatabases.values()).some((database) => database.db.isOpen);
}
/**
* Close shared state handles and clear terminal failure latches for test isolation.
* Worker retirement continues after return; await closeOpenClawStateDatabaseAsync()
* before raw SQLite or file access to a database that workers have used.
*/
function closeOpenClawStateDatabaseForTest() {
closeOpenClawStateDatabase();
terminalOpenLatch.clearAll();
}
/** Process-wide owner for cached shared-state handles and terminal open failures. */
const openClawStateDatabaseCache = {
assertOpenClawStateDatabaseFreshOpenAllowedAtPath,
assertOpenClawStateDatabaseOpenAllowed,
clearOpenClawStateDatabaseOpenFailure,
closeOpenClawStateDatabase,
closeOpenClawStateDatabaseByPath,
closeOpenClawStateDatabaseForTest,
closeOpenClawStateDatabaseHandle,
closeUnpublishedOpenClawStateDatabaseHandle,
closeStaleCachedOpenClawStateDatabase,
evictCachedOpenClawStateDatabase,
evictOpenClawStateDatabaseAfterCorruption,
getCachedOpenClawStateDatabase,
getOpenClawStateDatabaseRuntimeFailure: runtimeFailures.get,
getOpenClawStateDatabaseRecordedFailure: terminalOpenLatch.peek,
getOpenClawStateDatabaseIfOpenAtPath,
getKnownOpenClawStateDatabaseIdentity: asyncResources.knownIdentity,
isOpenClawStateDatabaseOpen,
publishOpenClawStateDatabase,
recordOpenClawStateDatabaseOpenFailure,
recordOpenClawStateDatabaseLifecycleOpenError,
touchStateDatabase
};
//#endregion
export { SqliteSchemaMismatchError as $, unknown as $t, isGatewayExternallySupervised as A, extractSqliteTableSchema as At, tableExists as B, runWithSqliteBusyTimeout as Bt, markOpenClawStateDatabaseFailure as C, sqliteIntegrityCheckSteps as Ct, getExistingOpenClawStateSchemaPath as D, admitSqliteSchema as Dt, captureOpenClawStateWorkerContextWithAdmission as E, openNodeSqliteDatabase as Et, SqliteWorkerError as F, GatewayStateOwnerContentionError as Ft, assertSqliteSchemaContains as G, boolean as Gt, tablePrimaryKeyColumns as H, applyPrivateModeSync as Ht, retainSqliteWorkerErrorCode as I, acquireStateDatabaseSchemaLease as It, collectSqliteSchemaIssues as J, looseObject as Jt, assertSqliteSchemaTablesPresent as K, custom as Kt, SQLITE_IDLE_HANDLE_TTL_MS as L, assertStateDatabaseAccessAllowed as Lt, requestSqliteWorkerSchemaMaintenance as M, splitSqlList as Mt, SQLITE_WORKER_MAX_MESSAGE_BYTES as N, runSqlitePinnedReadSnapshotSync as Nt, isExistingOpenClawStateSchema as O, invalidateSqliteSchemaFacts as Ot, SqliteWorkerAdmissionTimeoutError as P, ensureSqliteLibrarySelected as Pt, readSqliteSchemaCookie as Q, union as Qt, classifySqliteTableReadError as R, getStateDatabaseSchemaLease as Rt, findOpenClawStateDatabaseFailure as S, runSqliteIntegrityOperationSync as St, openTrackedStateDatabaseResult as T, markSqliteNativeOpenFailure as Tt, migrateSqliteSchemaToStrict as U, _enum as Ut, tableHasColumn as V, setSqliteBusyTimeout as Vt, migrateSqliteSchemaToStrictInTransaction as W, array as Wt, getCanonicalSqliteNamedIndexContracts as X, object as Xt, createSqliteTableContractReader as Y, number as Yt, getCanonicalSqliteTableNames as Z, string as Zt, assertSupportedStateSchemaVersion as _, withSqlitePostCommitPublications as _n, runSqliteDeferredTransactionSync as _t, recordOpenClawStateDatabaseOpenFailure as a, OpenClawStateExternalOwnershipError as an, prepareSqliteQuerySync as at, OpenClawStateDatabaseSchemaMigrationRequiredError as b, compareOpenClawVersions as bn, assertSqliteTableIntegrity as bt, retainOpenClawStateDatabaseForIdle as c, SqliteCoordinatorError as cn, configureSqlitePreSchemaPragmas as ct, SqliteSnapshotCleanupError as d, throwSqliteLifecycleErrors as dn, createSqliteWalReclamationResult as dt, StateDatabaseReadAdmissionInvalidatedError as en, compileSqliteQueryBindings as et, adoptPreparedLocation as f, assertExistingDatabaseIdentity as fn, coerceRequiredSqliteNumber as ft, CONTENT_VERSION_KEY as g, deferSqlitePostCommitPublication as gn, retainSqliteWriteAdmissionService as gt, acquireSqliteStagingToken as h, readDatabasePathIdentitySync as hn, assertTransactionUsable as ht, publishOpenClawStateDatabaseWorkerAdmission as i, observeOpenClawDatabaseMaintenanceResource as in, iterateSqliteQuerySync as it, createSqliteWorkerOperationAdmission as j, quoteSqliteIdentifier as jt, recordExistingOpenClawStateSchemaDatabase as k, runSqliteReadOperationSync as kt, acquireSqliteSnapshotReadToken as l, createSqliteLifecycleAggregateError as ln, registerSqliteCacheExitClose as lt, SQLITE_STAGING_TOKEN_FILES as m, readDatabasePathIdentity as mn, decodeMountInfoPath as mt, getOpenClawStateDatabaseTerminalFailureAsync as n, getOpenClawDatabaseMaintenanceScope as nn, executeSqliteQueryTakeFirstSync as nt, registerOpenClawStateDatabaseAsyncResource as o, OpenClawStateOwnershipError as on, DATABASE_QUARANTINE_READ_CLEANUP_ERROR_NAME as ot, removeTempDirectory as p, readDatabaseIdentityBirthtime as pn, normalizeSqliteNumber as pt, collectSqliteNamedIndexContract as q, literal as qt, openClawStateDatabaseCache as r, isStateDatabaseReadAdmissionInvalidatedError as rn, getNodeSqliteKysely as rt, registerOpenClawStateDatabaseLifecycleListener as s, OpenClawStateOwnershipMetadataError as sn, configureSqliteConnectionPragmas as st, captureOpenClawStateDatabaseReadAdmission as t, captureOpenClawDatabaseMaintenanceResource as tn, executeSqliteQuerySync as tt, createSqliteSnapshotStagingDirectorySync as u, runWithSqliteCleanup as un, runInSqliteMaintenanceContext as ut, readStateSchemaContentVersion as v, applyConfigEnvVars as vn, runSqliteImmediateTransactionSync as vt, openTrackedStateDatabase as w, isSqliteLockError as wt, normalizeOpenClawStateSchemaReadError as x, isTerminalSqliteIntegrityError as xt, readStateSchemaMigrationVersion as y, cloneEnvWithPlatformSemantics as yn, assertSqliteIntegrity as yt, ensureColumn as z, withStateDatabaseColdAdmission as zt };