@hasna/instructions 0.6.0 → 0.6.1

package/dist/chunks/local-a9nen65z.js

@@ -0,0 +1,694 @@
+// @bun
+import {
+  now,
+  slugify,
+  uuid
+} from "./index-ma2xmp6c.js";
+import {
+  boundedReadPage,
+  detectMachineContext,
+  getRawStoreRoot,
+  hasInstructionsEnvAuthorityIntent,
+  legacyProfileConfigBinding,
+  normalizeBoundedReadOptions,
+  normalizeOsFamily,
+  normalizeProfileAssetBinding,
+  normalizeProfileConfigBinding
+} from "./index-v7dkb384.js";
+import"./index-35z65jsa.js";
+import {
+  ConfigNotFoundError,
+  ProfileNotFoundError
+} from "./index-pkscjnj5.js";
+import"./index-nnwp92tk.js";
+
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+function getDbPath() {
+  if (process.env["HASNA_INSTRUCTIONS_DB_PATH"]) {
+    return process.env["HASNA_INSTRUCTIONS_DB_PATH"];
+  }
+  const dir = getRawStoreRoot();
+  mkdirSync(dir, { recursive: true });
+  return join(dir, "instructions.db");
+}
+var MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS configs (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    slug TEXT NOT NULL UNIQUE,
+    kind TEXT NOT NULL DEFAULT 'file',
+    category TEXT NOT NULL,
+    agent TEXT NOT NULL DEFAULT 'global',
+    target_path TEXT,
+    format TEXT NOT NULL DEFAULT 'text',
+    content TEXT NOT NULL DEFAULT '',
+    description TEXT,
+    tags TEXT NOT NULL DEFAULT '[]',
+    is_template INTEGER NOT NULL DEFAULT 0,
+    version INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    synced_at TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS config_snapshots (
+    id TEXT PRIMARY KEY,
+    config_id TEXT NOT NULL REFERENCES configs(id) ON DELETE CASCADE,
+    content TEXT NOT NULL,
+    version INTEGER NOT NULL,
+    created_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS profiles (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    slug TEXT NOT NULL UNIQUE,
+    description TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS profile_configs (
+    profile_id TEXT NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
+    config_id TEXT NOT NULL REFERENCES configs(id) ON DELETE CASCADE,
+    sort_order INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (profile_id, config_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS machines (
+    id TEXT PRIMARY KEY,
+    hostname TEXT NOT NULL UNIQUE,
+    os TEXT,
+    last_applied_at TEXT,
+    created_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER PRIMARY KEY
+  );
+
+  INSERT OR IGNORE INTO schema_version (version) VALUES (1);
+  `,
+  `
+  ALTER TABLE profiles ADD COLUMN selectors TEXT NOT NULL DEFAULT '{}';
+  ALTER TABLE profiles ADD COLUMN variables TEXT NOT NULL DEFAULT '{}';
+  ALTER TABLE machines ADD COLUMN arch TEXT;
+  `,
+  `
+  ALTER TABLE configs ADD COLUMN outputs TEXT NOT NULL DEFAULT '[]';
+  `,
+  `
+  ALTER TABLE profile_configs ADD COLUMN binding TEXT NOT NULL DEFAULT '{"schema":"hasna.instructions.profile-config-binding/v1","activation":{"mode":"always"},"required":true,"fallback":"fail"}';
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS profile_assets (
+    profile_id TEXT NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
+    source_config_id TEXT NOT NULL REFERENCES configs(id) ON DELETE CASCADE,
+    asset_key TEXT NOT NULL,
+    sort_order INTEGER NOT NULL DEFAULT 0,
+    binding TEXT NOT NULL,
+    PRIMARY KEY (profile_id, asset_key)
+  );
+  CREATE INDEX IF NOT EXISTS profile_assets_source_config_idx ON profile_assets (source_config_id);
+  `
+];
+var _db = null;
+function getDatabase(path) {
+  if (_db)
+    return _db;
+  if (!path && hasInstructionsEnvAuthorityIntent(process.env)) {
+    throw new Error("instructions: refusing to open the on-box SQLite store \u2014 the environment configures a hosted " + "Instructions authority or credential (HASNA_INSTRUCTIONS_*), and reading or writing the local store " + "here would silently drift from the shared dataset. Pass an explicit database path (or an injected " + "Database) to work against the on-box store deliberately.");
+  }
+  const dbPath = path || getDbPath();
+  const db = new Database(dbPath);
+  db.run("PRAGMA journal_mode = WAL");
+  db.run("PRAGMA foreign_keys = ON");
+  applyMigrations(db);
+  ensureFeedbackTable(db);
+  _db = db;
+  return db;
+}
+function resetDatabase() {
+  if (_db) {
+    try {
+      _db.close();
+    } catch {}
+  }
+  _db = null;
+}
+function resetLocalDatabase() {
+  resetDatabase();
+  const dbPath = getDbPath();
+  if (dbPath === ":memory:")
+    return;
+  for (const p of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+    if (existsSync(p))
+      rmSync(p);
+  }
+}
+function applyMigrations(db) {
+  let currentVersion = 0;
+  try {
+    const row = db.query("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get();
+    currentVersion = row?.version ?? 0;
+  } catch {
+    currentVersion = 0;
+  }
+  const applyOne = db.transaction((index) => {
+    if (!migrationEffectAlreadyPresent(db, index))
+      db.exec(MIGRATIONS[index]);
+    db.run(`INSERT OR REPLACE INTO schema_version (version) VALUES (${index + 1})`);
+  });
+  for (let i = currentVersion;i < MIGRATIONS.length; i++)
+    applyOne(i);
+}
+function migrationEffectAlreadyPresent(db, index) {
+  if (index !== 3)
+    return false;
+  return db.query("PRAGMA table_info(profile_configs)").all().some((column) => column.name === "binding");
+}
+function ensureFeedbackTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS feedback (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+      message TEXT NOT NULL,
+      email TEXT,
+      category TEXT DEFAULT 'general',
+      version TEXT,
+      machine_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  const existing = new Set(db.query("PRAGMA table_info(feedback)").all().map((r) => r.name));
+  const required = [
+    ["email", "TEXT"],
+    ["category", "TEXT DEFAULT 'general'"],
+    ["version", "TEXT"],
+    ["machine_id", "TEXT"],
+    ["created_at", "TEXT"]
+  ];
+  for (const [name, def] of required) {
+    if (!existing.has(name))
+      db.exec(`ALTER TABLE feedback ADD COLUMN ${name} ${def}`);
+  }
+}
+function insertFeedback(input, db) {
+  const d = db || getDatabase();
+  d.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", [input.message, input.email ?? null, input.category ?? "general", input.version ?? null]);
+}
+
+// src/db/snapshots.ts
+function createSnapshot(configId, content, version, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const ts = now();
+  d.run("INSERT INTO config_snapshots (id, config_id, content, version, created_at) VALUES (?, ?, ?, ?, ?)", [id, configId, content, version, ts]);
+  return { id, config_id: configId, content, version, created_at: ts };
+}
+function listSnapshots(configId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM config_snapshots WHERE config_id = ? ORDER BY version DESC").all(configId);
+}
+function getSnapshot(id, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM config_snapshots WHERE id = ?").get(id);
+}
+function getSnapshotByVersion(configId, version, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM config_snapshots WHERE config_id = ? AND version = ?").get(configId, version);
+}
+function pruneSnapshots(configId, keep = 10, db) {
+  const d = db || getDatabase();
+  const result = d.run(`DELETE FROM config_snapshots WHERE config_id = ? AND id NOT IN (
+      SELECT id FROM config_snapshots WHERE config_id = ? ORDER BY version DESC LIMIT ?
+    )`, [configId, configId, keep]);
+  return result.changes;
+}
+
+// src/db/configs.ts
+function rowToConfig(row) {
+  let outputs = [];
+  try {
+    const parsed = JSON.parse(row.outputs || "[]");
+    outputs = Array.isArray(parsed) ? parsed : [];
+  } catch {
+    outputs = [];
+  }
+  return {
+    ...row,
+    tags: JSON.parse(row.tags || "[]"),
+    outputs,
+    is_template: !!row.is_template,
+    kind: row.kind,
+    category: row.category,
+    agent: row.agent,
+    format: row.format
+  };
+}
+function uniqueSlug(name, db, excludeId) {
+  const base = slugify(name);
+  let slug = base;
+  let i = 1;
+  while (true) {
+    const existing = db.query("SELECT id FROM configs WHERE slug = ?").get(slug);
+    if (!existing || existing.id === excludeId)
+      return slug;
+    slug = `${base}-${i++}`;
+  }
+}
+function createConfig(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const ts = now();
+  const slug = uniqueSlug(input.name, d);
+  const tags = JSON.stringify(input.tags || []);
+  const outputs = JSON.stringify(input.outputs || []);
+  return d.transaction(() => {
+    d.run(`INSERT INTO configs (id, name, slug, kind, category, agent, target_path, outputs, format, content, description, tags, is_template, version, created_at, updated_at, synced_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, NULL)`, [
+      id,
+      input.name,
+      slug,
+      input.kind ?? "file",
+      input.category,
+      input.agent ?? "global",
+      input.target_path ?? null,
+      outputs,
+      input.format ?? "text",
+      input.content,
+      input.description ?? null,
+      tags,
+      input.is_template ? 1 : 0,
+      ts,
+      ts
+    ]);
+    createSnapshot(id, input.content, 1, d);
+    return getConfig(id, d);
+  })();
+}
+function getConfig(idOrSlug, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM configs WHERE id = ? OR slug = ?").get(idOrSlug, idOrSlug);
+  if (!row)
+    throw new ConfigNotFoundError(idOrSlug);
+  return rowToConfig(row);
+}
+function getConfigById(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM configs WHERE id = ?").get(id);
+  if (!row)
+    throw new ConfigNotFoundError(id);
+  return rowToConfig(row);
+}
+function listConfigs(filter, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter?.category) {
+    conditions.push("category = ?");
+    params.push(filter.category);
+  }
+  if (filter?.agent) {
+    conditions.push("agent = ?");
+    params.push(filter.agent);
+  }
+  if (filter?.kind) {
+    conditions.push("kind = ?");
+    params.push(filter.kind);
+  }
+  if (filter?.is_template !== undefined) {
+    conditions.push("is_template = ?");
+    params.push(filter.is_template ? 1 : 0);
+  }
+  if (filter?.search) {
+    conditions.push("(name LIKE ? OR description LIKE ? OR content LIKE ?)");
+    const q = `%${filter.search}%`;
+    params.push(q, q, q);
+  }
+  if (filter?.tags && filter.tags.length > 0) {
+    const tagConditions = filter.tags.map(() => "tags LIKE ?").join(" OR ");
+    conditions.push(`(${tagConditions})`);
+    for (const tag of filter.tags)
+      params.push(`%"${tag}"%`);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = d.query(`SELECT * FROM configs ${where} ORDER BY category, name`).all(...params);
+  return rows.map(rowToConfig);
+}
+function updateConfig(idOrSlug, input, db) {
+  const d = db || getDatabase();
+  const existing = getConfig(idOrSlug, d);
+  const ts = now();
+  const updates = ["updated_at = ?", "version = version + 1"];
+  const params = [ts];
+  if (input.name !== undefined) {
+    updates.push("name = ?", "slug = ?");
+    params.push(input.name, uniqueSlug(input.name, d, existing.id));
+  }
+  if (input.kind !== undefined) {
+    updates.push("kind = ?");
+    params.push(input.kind);
+  }
+  if (input.category !== undefined) {
+    updates.push("category = ?");
+    params.push(input.category);
+  }
+  if (input.agent !== undefined) {
+    updates.push("agent = ?");
+    params.push(input.agent);
+  }
+  if (input.target_path !== undefined) {
+    updates.push("target_path = ?");
+    params.push(input.target_path);
+  }
+  if (input.outputs !== undefined) {
+    updates.push("outputs = ?");
+    params.push(JSON.stringify(input.outputs));
+  }
+  if (input.format !== undefined) {
+    updates.push("format = ?");
+    params.push(input.format);
+  }
+  if (input.content !== undefined) {
+    updates.push("content = ?");
+    params.push(input.content);
+  }
+  if (input.description !== undefined) {
+    updates.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.tags !== undefined) {
+    updates.push("tags = ?");
+    params.push(JSON.stringify(input.tags));
+  }
+  if (input.is_template !== undefined) {
+    updates.push("is_template = ?");
+    params.push(input.is_template ? 1 : 0);
+  }
+  if (input.synced_at !== undefined) {
+    updates.push("synced_at = ?");
+    params.push(input.synced_at);
+  }
+  return d.transaction(() => {
+    params.push(existing.id);
+    d.run(`UPDATE configs SET ${updates.join(", ")} WHERE id = ?`, params);
+    const updated = getConfigById(existing.id, d);
+    createSnapshot(updated.id, updated.content, updated.version, d);
+    return updated;
+  })();
+}
+function deleteConfig(idOrSlug, db) {
+  const d = db || getDatabase();
+  const existing = getConfig(idOrSlug, d);
+  d.run("DELETE FROM configs WHERE id = ?", [existing.id]);
+}
+function getConfigStats(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT category, COUNT(*) as count FROM configs GROUP BY category").all();
+  const stats = { total: 0 };
+  for (const row of rows) {
+    stats[row.category] = row.count;
+    stats["total"] = (stats["total"] || 0) + row.count;
+  }
+  return stats;
+}
+// src/db/profiles.ts
+function rowToProfile(row) {
+  return {
+    ...row,
+    selectors: JSON.parse(row.selectors || "{}"),
+    variables: JSON.parse(row.variables || "{}")
+  };
+}
+function uniqueProfileSlug(name, db, excludeId) {
+  const base = slugify(name);
+  let slug = base;
+  let i = 1;
+  while (true) {
+    const existing = db.query("SELECT id FROM profiles WHERE slug = ?").get(slug);
+    if (!existing || existing.id === excludeId)
+      return slug;
+    slug = `${base}-${i++}`;
+  }
+}
+function createProfile(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const ts = now();
+  const slug = uniqueProfileSlug(input.name, d);
+  d.run("INSERT INTO profiles (id, name, slug, description, selectors, variables, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [
+    id,
+    input.name,
+    slug,
+    input.description ?? null,
+    JSON.stringify(input.selectors ?? {}),
+    JSON.stringify(input.variables ?? {}),
+    ts,
+    ts
+  ]);
+  return getProfile(id, d);
+}
+function getProfile(idOrSlug, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM profiles WHERE id = ? OR slug = ?").get(idOrSlug, idOrSlug);
+  if (!row)
+    throw new ProfileNotFoundError(idOrSlug);
+  return rowToProfile(row);
+}
+function listProfilesPage(options = {}, db) {
+  const d = db || getDatabase();
+  const normalized = normalizeBoundedReadOptions(options);
+  const total = d.query("SELECT COUNT(*) AS total FROM profiles").get()?.total ?? 0;
+  const rows = d.query("SELECT * FROM profiles ORDER BY name LIMIT ? OFFSET ?").all(normalized.limit, normalized.cursor).map(rowToProfile);
+  return boundedReadPage(rows, total, normalized);
+}
+function updateProfile(idOrSlug, input, db) {
+  const d = db || getDatabase();
+  const existing = getProfile(idOrSlug, d);
+  const ts = now();
+  const updates = ["updated_at = ?"];
+  const params = [ts];
+  if (input.name !== undefined) {
+    updates.push("name = ?", "slug = ?");
+    params.push(input.name, uniqueProfileSlug(input.name, d, existing.id));
+  }
+  if (input.description !== undefined) {
+    updates.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.selectors !== undefined) {
+    updates.push("selectors = ?");
+    params.push(JSON.stringify(input.selectors));
+  }
+  if (input.variables !== undefined) {
+    updates.push("variables = ?");
+    params.push(JSON.stringify(input.variables));
+  }
+  params.push(existing.id);
+  d.run(`UPDATE profiles SET ${updates.join(", ")} WHERE id = ?`, params);
+  return getProfile(existing.id, d);
+}
+function deleteProfile(idOrSlug, db) {
+  const d = db || getDatabase();
+  const existing = getProfile(idOrSlug, d);
+  d.run("DELETE FROM profiles WHERE id = ?", [existing.id]);
+}
+function addConfigToProfile(profileIdOrSlug, configId, db, binding) {
+  const d = db || getDatabase();
+  const profile = getProfile(profileIdOrSlug, d);
+  const maxRow = d.query("SELECT MAX(sort_order) as max_order FROM profile_configs WHERE profile_id = ?").get(profile.id);
+  const order = (maxRow?.max_order ?? -1) + 1;
+  d.run("INSERT OR IGNORE INTO profile_configs (profile_id, config_id, sort_order, binding) VALUES (?, ?, ?, ?)", [profile.id, configId, order, JSON.stringify(normalizeProfileConfigBinding(binding))]);
+}
+function setProfileConfigBinding(profileIdOrSlug, configId, binding, db) {
+  const d = db || getDatabase();
+  const profile = getProfile(profileIdOrSlug, d);
+  const normalized = normalizeProfileConfigBinding(binding);
+  const result = d.run("UPDATE profile_configs SET binding = ? WHERE profile_id = ? AND config_id = ?", [JSON.stringify(normalized), profile.id, configId]);
+  if (result.changes !== 1)
+    throw new Error(`Config ${configId} is not a member of profile ${profile.slug}.`);
+  return getProfileConfigBindings(profile.id, d).find((row) => row.config_id === configId);
+}
+function getProfileConfigBindings(profileIdOrSlug, db) {
+  const d = db || getDatabase();
+  const profile = getProfile(profileIdOrSlug, d);
+  return d.query("SELECT profile_id, config_id, sort_order, binding FROM profile_configs WHERE profile_id = ? ORDER BY sort_order, config_id").all(profile.id).map((row) => ({
+    profile_id: row.profile_id,
+    config_id: row.config_id,
+    sort_order: row.sort_order,
+    binding: row.binding ? normalizeProfileConfigBinding(row.binding) : legacyProfileConfigBinding()
+  }));
+}
+function removeConfigFromProfile(profileIdOrSlug, configId, db) {
+  const d = db || getDatabase();
+  const profile = getProfile(profileIdOrSlug, d);
+  d.run("DELETE FROM profile_configs WHERE profile_id = ? AND config_id = ?", [profile.id, configId]);
+}
+function addAssetToProfile(profileIdOrSlug, sourceConfigId, binding, db) {
+  const d = db || getDatabase();
+  const profile = getProfile(profileIdOrSlug, d);
+  getConfigById(sourceConfigId, d);
+  const normalized = normalizeProfileAssetBinding(binding);
+  const maxRow = d.query("SELECT MAX(sort_order) AS max_order FROM profile_assets WHERE profile_id = ?").get(profile.id);
+  const order = (maxRow?.max_order ?? -1) + 1;
+  d.run("INSERT INTO profile_assets (profile_id, source_config_id, asset_key, sort_order, binding) VALUES (?, ?, ?, ?, ?)", [profile.id, sourceConfigId, normalized.assetKey, order, JSON.stringify(normalized)]);
+  return getProfileAssetBindings(profile.id, d).find((row) => row.binding.assetKey === normalized.assetKey);
+}
+function setProfileAssetBinding(profileIdOrSlug, assetKey, binding, db) {
+  const d = db || getDatabase();
+  const profile = getProfile(profileIdOrSlug, d);
+  const normalized = normalizeProfileAssetBinding(binding);
+  if (normalized.assetKey !== assetKey)
+    throw new Error(`Asset binding key ${normalized.assetKey} does not match route key ${assetKey}.`);
+  const result = d.run("UPDATE profile_assets SET binding = ? WHERE profile_id = ? AND asset_key = ?", [JSON.stringify(normalized), profile.id, assetKey]);
+  if (result.changes !== 1)
+    throw new Error(`Asset ${assetKey} is not a member of profile ${profile.slug}.`);
+  return getProfileAssetBindings(profile.id, d).find((row) => row.binding.assetKey === assetKey);
+}
+function getProfileAssetBindings(profileIdOrSlug, db) {
+  const d = db || getDatabase();
+  const profile = getProfile(profileIdOrSlug, d);
+  return d.query("SELECT profile_id, source_config_id, sort_order, binding FROM profile_assets WHERE profile_id = ? ORDER BY sort_order, asset_key").all(profile.id).map((row) => ({
+    profile_id: row.profile_id,
+    source_config_id: row.source_config_id,
+    sort_order: row.sort_order,
+    binding: normalizeProfileAssetBinding(row.binding)
+  }));
+}
+function removeAssetFromProfile(profileIdOrSlug, assetKey, db) {
+  const d = db || getDatabase();
+  const profile = getProfile(profileIdOrSlug, d);
+  d.run("DELETE FROM profile_assets WHERE profile_id = ? AND asset_key = ?", [profile.id, assetKey]);
+}
+function getProfileConfigsPage(profileIdOrSlug, options = {}, db) {
+  const d = db || getDatabase();
+  const profile = getProfile(profileIdOrSlug, d);
+  const normalized = normalizeBoundedReadOptions(options);
+  const total = d.query("SELECT COUNT(*) AS total FROM profile_configs WHERE profile_id = ?").get(profile.id)?.total ?? 0;
+  const rows = d.query("SELECT config_id FROM profile_configs WHERE profile_id = ? ORDER BY sort_order LIMIT ? OFFSET ?").all(profile.id, normalized.limit, normalized.cursor);
+  return boundedReadPage(rows.map((row) => getConfigById(row.config_id, d)), total, normalized);
+}
+function profileHasSelectors(profile) {
+  const selectors = profile.selectors ?? {};
+  return (selectors.os?.length ?? 0) > 0 || (selectors.arch?.length ?? 0) > 0 || (selectors.hostnames?.length ?? 0) > 0;
+}
+function profileMatchesMachine(profile, machine) {
+  const selectors = profile.selectors ?? {};
+  const osMatches = !selectors.os?.length || selectors.os.some((candidate) => {
+    const value = candidate.trim().toLowerCase();
+    return value === machine.os_family || value === (machine.os ?? "").trim().toLowerCase() || normalizeOsFamily(candidate) === machine.os_family;
+  });
+  const archMatches = !selectors.arch?.length || selectors.arch.some((candidate) => candidate.trim().toLowerCase() === (machine.arch ?? "").trim().toLowerCase());
+  const hostnameMatches = !selectors.hostnames?.length || selectors.hostnames.some((candidate) => candidate.trim().toLowerCase() === machine.hostname.trim().toLowerCase());
+  return osMatches && archMatches && hostnameMatches;
+}
+function resolveProfileForMachineRead(machine = detectMachineContext(), options = {}, db) {
+  const d = db || getDatabase();
+  const { limit } = normalizeBoundedReadOptions(options);
+  let cursor = 0;
+  let scanned = 0;
+  let total = 0;
+  let selected = null;
+  while (true) {
+    const page = listProfilesPage({ limit, cursor }, d);
+    total = page.total;
+    scanned += page.items.length;
+    for (const profile of page.items) {
+      if (!profileHasSelectors(profile) || !profileMatchesMachine(profile, machine))
+        continue;
+      const selectors = profile.selectors;
+      const score = (selectors.hostnames?.length ? 100 : 0) + (selectors.os?.length ? 10 : 0) + (selectors.arch?.length ? 10 : 0);
+      if (!selected || score > selected.score || score === selected.score && profile.name.localeCompare(selected.profile.name) < 0) {
+        selected = { profile, score };
+      }
+    }
+    if (page.complete)
+      break;
+    cursor = page.next_cursor;
+  }
+  return {
+    profile: selected?.profile ?? null,
+    scanned,
+    total,
+    batch_limit: limit,
+    source_bounded: true,
+    complete: true,
+    truncated: false
+  };
+}
+// src/db/machines.ts
+import { arch, hostname, type } from "os";
+function currentHostname() {
+  return hostname();
+}
+function currentOs() {
+  return type();
+}
+function currentArch() {
+  return arch();
+}
+function registerMachine(hostnameStr, os, archStr, db) {
+  const d = db || getDatabase();
+  const h = hostnameStr ?? currentHostname();
+  const o = os ?? currentOs();
+  const a = archStr ?? currentArch();
+  const existing = d.query("SELECT * FROM machines WHERE hostname = ?").get(h);
+  if (existing) {
+    if (existing.os !== o || existing.arch !== a) {
+      d.run("UPDATE machines SET os = ?, arch = ? WHERE hostname = ?", [o, a, h]);
+      return d.query("SELECT * FROM machines WHERE hostname = ?").get(h);
+    }
+    return existing;
+  }
+  const id = uuid();
+  const ts = now();
+  d.run("INSERT INTO machines (id, hostname, os, arch, last_applied_at, created_at) VALUES (?, ?, ?, ?, NULL, ?)", [id, h, o, a, ts]);
+  return d.query("SELECT * FROM machines WHERE id = ?").get(id);
+}
+function updateMachineApplied(hostnameStr, db) {
+  const d = db || getDatabase();
+  const h = hostnameStr ?? currentHostname();
+  d.run("UPDATE machines SET last_applied_at = ? WHERE hostname = ?", [now(), h]);
+}
+function listMachines(db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM machines ORDER BY last_applied_at DESC NULLS LAST").all();
+}
+export {
+  updateProfile,
+  updateMachineApplied,
+  updateConfig,
+  setProfileConfigBinding,
+  setProfileAssetBinding,
+  resolveProfileForMachineRead,
+  resetLocalDatabase,
+  removeConfigFromProfile,
+  removeAssetFromProfile,
+  registerMachine,
+  pruneSnapshots,
+  listSnapshots,
+  listProfilesPage,
+  listMachines,
+  listConfigs,
+  insertFeedback,
+  getSnapshotByVersion,
+  getSnapshot,
+  getProfileConfigsPage,
+  getProfileConfigBindings,
+  getProfileAssetBindings,
+  getProfile,
+  getConfigStats,
+  getConfigById,
+  getConfig,
+  deleteProfile,
+  deleteConfig,
+  createSnapshot,
+  createProfile,
+  createConfig,
+  addConfigToProfile,
+  addAssetToProfile
+};