@camstack/system 1.2.318 → 1.2.319

package/dist/builtins/backup-orchestrator/backup-orchestrator.addon.js

@@ -3168,7 +3168,6 @@ var SystemBackupService = class {
 		}
 		if (present.length === 0) throw new Error(`createArchive: no locations from {${requested.join(", ")}} exist under ${this.dataDir}`);
 		node_fs.mkdirSync(node_path.dirname(opts.archivePath), { recursive: true });
-		await this.checkpointDatabasesUnder(present);
 		const entries = [];
 		for (const loc of present) {
 			throwIfCancelled(opts.signal);
@@ -3241,48 +3240,6 @@ var SystemBackupService = class {
 		};
 	}
 	/**
-	* Best-effort `wal_checkpoint(TRUNCATE)` on every live SQLite database
-	* under the locations about to be archived. Discovers a DB by its
-	* `-wal` sidecar (only WAL-mode DBs have one, and only those need
-	* folding), opens a short-lived second connection — SQLite permits
-	* concurrent connections, and a checkpoint is a supported concurrent
-	* operation against the hub's live writer — checkpoints, and closes.
-	*
-	* Every failure is swallowed: a `SQLITE_BUSY`, a locked file, a
-	* missing native binding, or a non-DB `.db` file must not fail the
-	* backup. A residual WAL still restores correctly; the checkpoint is a
-	* consistency *improvement*, not a precondition.
-	*/
-	async checkpointDatabasesUnder(locations) {
-		const dbPaths = /* @__PURE__ */ new Set();
-		for (const loc of locations) await collectWalDatabases(node_path.isAbsolute(loc) ? loc : node_path.join(this.dataDir, loc), dbPaths, this.exclusionPredicate());
-		if (dbPaths.size === 0) return;
-		let Database;
-		try {
-			Database = (await import("better-sqlite3")).default;
-		} catch (err) {
-			this.logger.warn("createArchive: better-sqlite3 unavailable — skipping WAL checkpoint", { meta: {
-				error: err instanceof Error ? err.message : String(err),
-				dbCount: dbPaths.size
-			} });
-			return;
-		}
-		for (const dbPath of dbPaths) try {
-			const db = new Database(dbPath);
-			try {
-				db.pragma("wal_checkpoint(PASSIVE)");
-			} finally {
-				db.close();
-			}
-			this.logger.debug("createArchive: checkpointed DB", { meta: { dbPath } });
-		} catch (err) {
-			this.logger.warn("createArchive: WAL checkpoint failed — archiving DB as-is", { meta: {
-				dbPath,
-				error: err instanceof Error ? err.message : String(err)
-			} });
-		}
-	}
-	/**
 	* without extracting payload files. Streams the tar.gz, parses the
 	* one entry we care about, then aborts.
 	*/
@@ -3402,45 +3359,14 @@ var SystemBackupService = class {
 	}
 	/**
 	* Absolute-path form of {@link isExcludedFromBackup}, anchored on
-	* this service's dataDir. Shared by the manifest walk, the location
-	* stats and the WAL-checkpoint scan so all three agree with the tar
-	* filter about what a backup contains.
+	* this service's dataDir. Shared by the manifest walk and the location
+	* stats so both agree with the tar filter about what a backup contains.
 	*/
 	exclusionPredicate() {
 		return (abs) => isExcludedFromBackup(node_path.relative(this.dataDir, abs));
 	}
 };
 /**
-* Recursively collect every SQLite database under `abs` that is in WAL
-* mode, identified by the presence of a `<db>-wal` sidecar. Only those
-* need a checkpoint; a rollback-journal DB has nothing to fold. Errors
-* (unreadable dir, broken symlink) are skipped silently — this feeds a
-* best-effort step.
-*/
-async function collectWalDatabases(abs, out, shouldSkip) {
-	if (shouldSkip?.(abs)) return;
-	let stat;
-	try {
-		stat = await node_fs_promises.stat(abs);
-	} catch {
-		return;
-	}
-	if (stat.isDirectory()) {
-		let children;
-		try {
-			children = await node_fs_promises.readdir(abs);
-		} catch {
-			return;
-		}
-		for (const child of children) await collectWalDatabases(node_path.join(abs, child), out, shouldSkip);
-		return;
-	}
-	if (abs.endsWith("-wal")) {
-		const dbPath = abs.slice(0, -4);
-		if (node_fs.existsSync(dbPath)) out.add(dbPath);
-	}
-}
-/**
 * Recursively walk a directory and produce one `ArchiveEntry` per
 * filesystem node. `dataDir` is used to compute the archive-relative
 * path. Symlinks are dereferenced (matches the `follow: true` flag we

package/dist/builtins/backup-orchestrator/backup-orchestrator.addon.mjs

@@ -3153,7 +3153,6 @@ var SystemBackupService = class {
 		}
 		if (present.length === 0) throw new Error(`createArchive: no locations from {${requested.join(", ")}} exist under ${this.dataDir}`);
 		fs.mkdirSync(path$1.dirname(opts.archivePath), { recursive: true });
-		await this.checkpointDatabasesUnder(present);
 		const entries = [];
 		for (const loc of present) {
 			throwIfCancelled(opts.signal);
@@ -3226,48 +3225,6 @@ var SystemBackupService = class {
 		};
 	}
 	/**
-	* Best-effort `wal_checkpoint(TRUNCATE)` on every live SQLite database
-	* under the locations about to be archived. Discovers a DB by its
-	* `-wal` sidecar (only WAL-mode DBs have one, and only those need
-	* folding), opens a short-lived second connection — SQLite permits
-	* concurrent connections, and a checkpoint is a supported concurrent
-	* operation against the hub's live writer — checkpoints, and closes.
-	*
-	* Every failure is swallowed: a `SQLITE_BUSY`, a locked file, a
-	* missing native binding, or a non-DB `.db` file must not fail the
-	* backup. A residual WAL still restores correctly; the checkpoint is a
-	* consistency *improvement*, not a precondition.
-	*/
-	async checkpointDatabasesUnder(locations) {
-		const dbPaths = /* @__PURE__ */ new Set();
-		for (const loc of locations) await collectWalDatabases(path$1.isAbsolute(loc) ? loc : path$1.join(this.dataDir, loc), dbPaths, this.exclusionPredicate());
-		if (dbPaths.size === 0) return;
-		let Database;
-		try {
-			Database = (await import("better-sqlite3")).default;
-		} catch (err) {
-			this.logger.warn("createArchive: better-sqlite3 unavailable — skipping WAL checkpoint", { meta: {
-				error: err instanceof Error ? err.message : String(err),
-				dbCount: dbPaths.size
-			} });
-			return;
-		}
-		for (const dbPath of dbPaths) try {
-			const db = new Database(dbPath);
-			try {
-				db.pragma("wal_checkpoint(PASSIVE)");
-			} finally {
-				db.close();
-			}
-			this.logger.debug("createArchive: checkpointed DB", { meta: { dbPath } });
-		} catch (err) {
-			this.logger.warn("createArchive: WAL checkpoint failed — archiving DB as-is", { meta: {
-				dbPath,
-				error: err instanceof Error ? err.message : String(err)
-			} });
-		}
-	}
-	/**
 	* without extracting payload files. Streams the tar.gz, parses the
 	* one entry we care about, then aborts.
 	*/
@@ -3387,45 +3344,14 @@ var SystemBackupService = class {
 	}
 	/**
 	* Absolute-path form of {@link isExcludedFromBackup}, anchored on
-	* this service's dataDir. Shared by the manifest walk, the location
-	* stats and the WAL-checkpoint scan so all three agree with the tar
-	* filter about what a backup contains.
+	* this service's dataDir. Shared by the manifest walk and the location
+	* stats so both agree with the tar filter about what a backup contains.
 	*/
 	exclusionPredicate() {
 		return (abs) => isExcludedFromBackup(path$1.relative(this.dataDir, abs));
 	}
 };
 /**
-* Recursively collect every SQLite database under `abs` that is in WAL
-* mode, identified by the presence of a `<db>-wal` sidecar. Only those
-* need a checkpoint; a rollback-journal DB has nothing to fold. Errors
-* (unreadable dir, broken symlink) are skipped silently — this feeds a
-* best-effort step.
-*/
-async function collectWalDatabases(abs, out, shouldSkip) {
-	if (shouldSkip?.(abs)) return;
-	let stat;
-	try {
-		stat = await fsp.stat(abs);
-	} catch {
-		return;
-	}
-	if (stat.isDirectory()) {
-		let children;
-		try {
-			children = await fsp.readdir(abs);
-		} catch {
-			return;
-		}
-		for (const child of children) await collectWalDatabases(path$1.join(abs, child), out, shouldSkip);
-		return;
-	}
-	if (abs.endsWith("-wal")) {
-		const dbPath = abs.slice(0, -4);
-		if (fs.existsSync(dbPath)) out.add(dbPath);
-	}
-}
-/**
 * Recursively walk a directory and produce one `ArchiveEntry` per
 * filesystem node. `dataDir` is used to compute the archive-relative
 * path. Symlinks are dereferenced (matches the `follow: true` flag we

package/dist/builtins/composer/composer-apply-waits.d.ts

@@ -0,0 +1,21 @@
+import { ComposerApplyInput, ComposerApplyResult, IScopedLogger } from '@camstack/types';
+/** An apply either waits, naming why, or goes on with the reconciled integration. */
+export type ApplyGate = {
+    readonly kind: 'wait';
+    readonly reason: string;
+} | {
+    readonly kind: 'go';
+    readonly integrationId: string;
+};
+export declare class ApplyWaits {
+    private readonly logger;
+    /** Consecutive applies refused because `core_blocks` had not loaded: warned once per run. */
+    private storeWaitApplies;
+    /** Consecutive applies refused because the Blocks integration had not reconciled: warned once per run. */
+    private integrationWaitApplies;
+    constructor(logger: IScopedLogger);
+    /** Whether this apply must act on nothing (and why), or may go on. */
+    check(input: ComposerApplyInput, liveCount: number): ApplyGate;
+}
+/** Every block `starting`, naming the wait; nothing acted. */
+export declare function waitingResult(blockIds: readonly string[], reason: string): ComposerApplyResult;

package/dist/builtins/composer/composer-live-set.d.ts

@@ -0,0 +1,22 @@
+import { ClaimGate, ClaimKey } from './claim-gate.js';
+import { PlannedBlock } from './composer-plan.js';
+import { LiveComposition } from './composer-verdict.js';
+import { TrackedSourceRequest } from './source-tracker.js';
+/** A release answered with one of these hands back nothing of ours: the gate forgets the claim. */
+export declare const RELEASE_SETTLED_CODES: ReadonlySet<string>;
+/**
+ * The source keys an operator action on `p` re-opens: every source its fields
+ * read, except its own target (re-resolved by `planExisting` already, never
+ * twice).
+ */
+export declare function operatorResetKeys(p: PlannedBlock): readonly string[];
+/** Every source the live set reads, with the view each own cap is read in. */
+export declare function trackedSourceRequests(live: Iterable<LiveComposition>): readonly TrackedSourceRequest[];
+/**
+ * Rule 3: the claims every live customization WANTS this apply; everything
+ * else the gate knows is a release candidate, handed back once two applies
+ * agree. A block that cannot plan — waiting, unreadable, failed, or with its
+ * target gone — HOLDS its claims (rule 4, rule 5): they are wanted as they
+ * are. A disabled block wants none (rule 7).
+ */
+export declare function wantedClaims(live: ReadonlyMap<string, LiveComposition>, claimGate: Pick<ClaimGate, 'claimsOf'>): readonly ClaimKey[];

package/dist/builtins/composer/composer-runtime-factory.d.ts

@@ -0,0 +1,22 @@
+import { CapabilityLookup, IScopedLogger } from '@camstack/types';
+import { ComposedDeviceHandle } from './composed-device.js';
+import { PlannedBlock } from './composer-plan.js';
+import { ComposedWriteTarget, CompositionEventEmitter, CompositionRuntime, DeadlineTimer } from './composition-runtime.js';
+import { ComposerClaimsApi, ExistingTargetSeedRead } from './existing-target.js';
+import { ClaimEvent } from './held-claims.js';
+import { SourceTracker } from './source-tracker.js';
+/** The composer dependencies a runtime and its write target are built from. */
+export interface RuntimeFactoryDeps {
+    readonly logger: IScopedLogger;
+    readonly claims: ComposerClaimsApi;
+    readonly tracker: SourceTracker;
+    readonly events: CompositionEventEmitter;
+    readonly lookupCap: CapabilityLookup;
+    readonly now: () => number;
+    readonly newTimer: () => DeadlineTimer;
+}
+/** Where a block's own claim transitions are followed (C-1/N-1). */
+export type ClaimEventSink = (deviceId: number, cap: string, owner: string, event: ClaimEvent) => void;
+/** Where a block's runtime writes: its composed device, or a claim-backed target on the existing device. */
+export declare function writerFor(deps: RuntimeFactoryDeps, p: PlannedBlock, device: ComposedDeviceHandle | null, onClaimEvent: ClaimEventSink): ComposedWriteTarget | null;
+export declare function newCompositionRuntime(deps: RuntimeFactoryDeps, p: PlannedBlock, target: ComposedWriteTarget, seed?: ExistingTargetSeedRead): CompositionRuntime;

package/dist/builtins/composer/composer-seeds.d.ts

@@ -0,0 +1,22 @@
+import { FieldClaim, IScopedLogger } from '@camstack/types';
+import { PersistedComposedRow } from './composition-declarations.js';
+import { ConfirmedSeed } from './confirmed-seed.js';
+import { ComposerClaimsApi } from './existing-target.js';
+export interface ComposedRowSeedDeps {
+    readonly logger: IScopedLogger;
+    /** The composed rows that already exist (`listOwnDevices`). */
+    readonly readPersisted: () => Promise<readonly PersistedComposedRow[]>;
+    readonly onSeeded: (rows: readonly PersistedComposedRow[]) => void;
+}
+/** The rows the composer owns, read ONCE before its first withdrawal decision. */
+export declare function composedRowSeed(deps: ComposedRowSeedDeps): ConfirmedSeed<PersistedComposedRow>;
+export interface ClaimIndexSeedDeps {
+    readonly logger: IScopedLogger;
+    readonly claims: ComposerClaimsApi;
+    readonly onSeeded: (claims: readonly FieldClaim[]) => void;
+}
+/**
+ * The claims the hub holds, read ONCE before the first release decision (rule
+ * 3). `not-loaded` is UNKNOWN (D315), never empty.
+ */
+export declare function claimIndexSeed(deps: ClaimIndexSeedDeps): ConfirmedSeed<FieldClaim>;