@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/senses/bluebubbles/semantic-receipts.js

@@ -0,0 +1,1986 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlueBubblesSemanticPaths = getBlueBubblesSemanticPaths;
+exports.getBlueBubblesSemanticPathsAtRoot = getBlueBubblesSemanticPathsAtRoot;
+exports.serializeBlueBubblesSemanticJson = serializeBlueBubblesSemanticJson;
+exports.normalizeIngressIdentifier = normalizeIngressIdentifier;
+exports.hashIngressActorIdentity = hashIngressActorIdentity;
+exports.normalizeIngressParticipants = normalizeIngressParticipants;
+exports.initializeBlueBubblesSemanticCutover = initializeBlueBubblesSemanticCutover;
+exports.rotateBlueBubblesSemanticCutover = rotateBlueBubblesSemanticCutover;
+exports.readBlueBubblesSemanticCutover = readBlueBubblesSemanticCutover;
+exports.readBlueBubblesSemanticCutoverAtRoot = readBlueBubblesSemanticCutoverAtRoot;
+exports.buildBlueBubblesSemanticIdentity = buildBlueBubblesSemanticIdentity;
+exports.buildBlueBubblesSemanticCapture = buildBlueBubblesSemanticCapture;
+exports.buildBlueBubblesReactionCoordinateRecord = buildBlueBubblesReactionCoordinateRecord;
+exports.buildBlueBubblesSemanticClaimRecord = buildBlueBubblesSemanticClaimRecord;
+exports.classifyBlueBubblesRecoveryRecord = classifyBlueBubblesRecoveryRecord;
+exports.writeBlueBubblesSemanticCapture = writeBlueBubblesSemanticCapture;
+exports.readBlueBubblesSemanticCapture = readBlueBubblesSemanticCapture;
+exports.readBlueBubblesSemanticCaptureAtRoot = readBlueBubblesSemanticCaptureAtRoot;
+exports.listPendingBlueBubblesSemanticCaptures = listPendingBlueBubblesSemanticCaptures;
+exports.compareBlueBubblesSemanticCaptureOrder = compareBlueBubblesSemanticCaptureOrder;
+exports.writeBlueBubblesSemanticHandled = writeBlueBubblesSemanticHandled;
+exports.readBlueBubblesSemanticHandled = readBlueBubblesSemanticHandled;
+exports.acquireBlueBubblesSemanticClaim = acquireBlueBubblesSemanticClaim;
+exports.releaseBlueBubblesSemanticClaim = releaseBlueBubblesSemanticClaim;
+exports.allocateBlueBubblesReactionCoordinate = allocateBlueBubblesReactionCoordinate;
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
+const UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const ISO_MILLISECONDS_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+const CUTOVER_KEYS = ["schemaVersion", "providerNamespace", "effectiveAt"];
+const CANONICAL_VALUES = new Set([
+    "love",
+    "like",
+    "dislike",
+    "laugh",
+    "emphasize",
+    "question",
+    "custom",
+    "unknown",
+]);
+const CANONICAL_ACTIONS = new Set(["add", "remove"]);
+const SEMANTIC_KEY_HASH_PATTERN = /^[0-9a-f]{64}$/;
+const SEMANTIC_CLAIM_POLL_MS = 50;
+const SEMANTIC_CLAIM_TIMEOUT_MS = 5_000;
+const SEMANTIC_OWNERSHIP_SCHEMA_VERSION = 1;
+const SEMANTIC_OWNERSHIP_SCHEMA_SQL = `CREATE TABLE owner_leases (
+      resource_key TEXT PRIMARY KEY,
+      lease_id TEXT NOT NULL,
+      owner_json TEXT NOT NULL
+    ) STRICT, WITHOUT ROWID`;
+const CAPTURE_KEYS = ["schemaVersion", "canonicalKey", "keyHash", "providerNamespace", "capturedAt", "event"];
+const OBSERVATION_ORDER_KEYS = [
+    "schemaVersion",
+    "keyHash",
+    "captureHash",
+    "observedAt",
+    "observationEpoch",
+    "observationOrdinal",
+];
+const CAPTURE_EVENT_KEYS = [
+    "provider",
+    "kind",
+    "eventGuid",
+    "fromMe",
+    "actor",
+    "participants",
+    "sourceEventType",
+    "sessionKey",
+    "chatGuid",
+    "chatIdentifier",
+    "text",
+    "textSha256",
+    "targetGuid",
+    "targetAuthorship",
+    "canonicalAction",
+    "canonicalValue",
+    "rawTransportValue",
+    "effectiveAt",
+    "revision",
+    "contentSha256",
+];
+const OBSERVED_IDENTITY_KEYS = ["provider", "externalId", "displayName"];
+const CLAIM_KEYS = ["schemaVersion", "canonicalKey", "keyHash", "owner"];
+const CLAIM_OWNER_KEYS = ["operationId", "pid", "bootIdentity", "processStartedAt", "acquiredAt"];
+const HANDLED_KEYS = ["schemaVersion", "canonicalKey", "keyHash", "handledAt", "outcome", "detailCode"];
+const COORDINATE_KEYS = [
+    "schemaVersion",
+    "coordinateKey",
+    "coordinateHash",
+    "generation",
+    "lastAction",
+    "updatedAt",
+];
+const SEMANTIC_EVENT_KINDS = new Set(["message", "reaction", "edit", "unsend", "read", "delivery"]);
+const SEMANTIC_HANDLED_OUTCOMES = new Set([
+    "ignored_self",
+    "capture_only_removal",
+    "capture_only_positive",
+    "capture_only_custom",
+    "capture_only_unknown",
+    "capture_only_target_not_agent",
+    "capture_only_untrusted_actor",
+    "restricted_feedback_settled",
+    "restricted_feedback_observed",
+    "restricted_feedback_failed",
+    "message_completed",
+    "message_observed",
+    "message_failed",
+    "edit_capture_only",
+    "unsend_capture_only",
+    "read_audit_only",
+    "delivery_audit_only",
+]);
+const lastOwnerAcquisitionMs = new Map();
+const semanticClaimLeaseIds = new WeakMap();
+function getBlueBubblesSemanticPaths(agentName) {
+    return getBlueBubblesSemanticPathsAtRoot((0, identity_1.getAgentRoot)(agentName));
+}
+function getBlueBubblesSemanticPathsAtRoot(agentRoot) {
+    const root = path.join(agentRoot, "state", "senses", "bluebubbles", "semantic-receipts");
+    return {
+        root,
+        cutover: path.join(root, "cutover.json"),
+        captures: path.join(root, "captures"),
+        observationOrders: path.join(root, "observation-orders"),
+        handled: path.join(root, "handled"),
+        claims: path.join(root, "claims"),
+        coordinates: path.join(root, "coordinates"),
+        quarantine: path.join(root, "quarantine"),
+        ownership: path.join(root, "ownership.sqlite"),
+    };
+}
+function serializeBlueBubblesSemanticJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function normalizeIngressIdentifier(value) {
+    return String(value).trim().toLowerCase();
+}
+function hashIngressActorIdentity(externalId) {
+    const normalized = normalizeIngressIdentifier(externalId);
+    return sha256Utf8(JSON.stringify(["imessage-handle", normalized]));
+}
+function normalizeIngressParticipants(participants) {
+    return participants
+        .map((participant) => ({
+        provider: "imessage-handle",
+        externalId: normalizeIngressIdentifier(participant.externalId),
+        displayName: normalizeDisplayName(participant.displayName),
+    }))
+        .filter((participant) => participant.externalId.length > 0)
+        .sort((left, right) => left.externalId.localeCompare(right.externalId));
+}
+function initializeBlueBubblesSemanticCutover(agentName, deps = {}) {
+    const paths = getBlueBubblesSemanticPaths(agentName);
+    const existing = readBlueBubblesSemanticCutover(agentName);
+    if (existing)
+        return existing;
+    if (fs.existsSync(paths.cutover))
+        throw new Error("semantic_cutover_invalid");
+    const marker = createCutover(deps);
+    fs.mkdirSync(paths.root, { recursive: true });
+    const tempPath = path.join(paths.root, `.cutover.json.${process.pid}.${marker.providerNamespace}.tmp`);
+    let tempFd = null;
+    let tempOwned = false;
+    let published = false;
+    let primaryError;
+    try {
+        tempFd = fs.openSync(tempPath, "wx", 0o600);
+        tempOwned = true;
+        fs.writeFileSync(tempFd, serializeBlueBubblesSemanticJson(marker), "utf8");
+        fs.fsyncSync(tempFd);
+        fs.closeSync(tempFd);
+        tempFd = null;
+        try {
+            fs.linkSync(tempPath, paths.cutover);
+            published = true;
+            fsyncDirectory(paths.root);
+        }
+        catch (error) {
+            if (!isNodeError(error, "EEXIST"))
+                throw error;
+        }
+    }
+    catch (error) {
+        primaryError = error;
+        throw error;
+    }
+    finally {
+        let cleanupError;
+        if (tempFd !== null) {
+            try {
+                fs.closeSync(tempFd);
+            }
+            catch (error) {
+                cleanupError = error;
+            }
+        }
+        if (tempOwned) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch (error) {
+                if (!isNodeError(error, "ENOENT") && cleanupError === undefined)
+                    cleanupError = error;
+            }
+        }
+        if (primaryError === undefined && cleanupError !== undefined)
+            throw cleanupError;
+    }
+    if (!published) {
+        const winner = readBlueBubblesSemanticCutover(agentName);
+        if (!winner)
+            throw new Error("semantic_cutover_invalid");
+        return winner;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_semantic_cutover_initialized",
+        message: "initialized bluebubbles semantic cutover",
+        meta: { agentName, schemaVersion: 1 },
+    });
+    return marker;
+}
+function rotateBlueBubblesSemanticCutover(agentName, reason, deps = {}) {
+    const paths = getBlueBubblesSemanticPaths(agentName);
+    const marker = createCutover(deps);
+    fs.mkdirSync(paths.root, { recursive: true });
+    const tempPath = path.join(paths.root, `.cutover.json.${process.pid}.${marker.providerNamespace}.tmp`);
+    let tempFd = null;
+    let tempOwned = false;
+    let primaryError;
+    try {
+        tempFd = fs.openSync(tempPath, "wx", 0o600);
+        tempOwned = true;
+        fs.writeFileSync(tempFd, serializeBlueBubblesSemanticJson(marker), "utf8");
+        fs.fsyncSync(tempFd);
+        fs.closeSync(tempFd);
+        tempFd = null;
+        fs.renameSync(tempPath, paths.cutover);
+        fsyncDirectory(paths.root);
+    }
+    catch (error) {
+        primaryError = error;
+        throw error;
+    }
+    finally {
+        let cleanupError;
+        if (tempFd !== null) {
+            try {
+                fs.closeSync(tempFd);
+            }
+            catch (error) {
+                cleanupError = error;
+            }
+        }
+        if (tempOwned) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch (error) {
+                if (!isNodeError(error, "ENOENT") && cleanupError === undefined)
+                    cleanupError = error;
+            }
+        }
+        if (primaryError === undefined && cleanupError !== undefined)
+            throw cleanupError;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_semantic_cutover_rotated",
+        message: "rotated bluebubbles semantic provider namespace",
+        meta: { agentName, reason, schemaVersion: 1 },
+    });
+    return marker;
+}
+function readBlueBubblesSemanticCutover(agentName) {
+    return readBlueBubblesSemanticCutoverAtRoot((0, identity_1.getAgentRoot)(agentName), {}, agentName);
+}
+function readBlueBubblesSemanticCutoverAtRoot(agentRoot, deps = {}, diagnosticIdentity = path.basename(agentRoot)) {
+    const storeFs = deps.fs ?? fs;
+    const filePath = getBlueBubblesSemanticPathsAtRoot(agentRoot).cutover;
+    if (!storeFs.existsSync(filePath))
+        return null;
+    try {
+        const parsed = JSON.parse(storeFs.readFileSync(filePath, "utf8"));
+        return isBlueBubblesSemanticCutover(parsed) ? parsed : null;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.bluebubbles_semantic_cutover_error",
+            message: "failed to read bluebubbles semantic cutover",
+            meta: {
+                agentName: diagnosticIdentity,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return null;
+    }
+}
+function buildBlueBubblesSemanticIdentity(input) {
+    const providerNamespace = normalizeProviderNamespace(input.providerNamespace);
+    if (!providerNamespace)
+        return null;
+    if (input.kind === "message") {
+        const eventGuid = requiredIdentifier(input.eventGuid);
+        if (!eventGuid)
+            return null;
+        return identityFromKey(["bb-sem-v1", providerNamespace, "message", eventGuid], true);
+    }
+    if (input.kind === "reaction") {
+        const eventGuid = requiredIdentifier(input.eventGuid);
+        const targetGuid = requiredIdentifier(input.targetGuid);
+        const actorExternalId = requiredIdentifier(input.actorExternalId);
+        const canonicalValue = normalizeCanonicalValue(input.canonicalValue);
+        const canonicalAction = normalizeCanonicalAction(input.canonicalAction);
+        if (!eventGuid || !targetGuid || !actorExternalId || !canonicalValue || !canonicalAction)
+            return null;
+        const actorIdentityHash = hashIngressActorIdentity(actorExternalId);
+        const coordinateTuple = [
+            "bb-sem-v1",
+            providerNamespace,
+            "reaction-coordinate",
+            eventGuid,
+            targetGuid,
+            actorIdentityHash,
+            canonicalValue,
+        ];
+        const coordinateKey = JSON.stringify(coordinateTuple);
+        const coordinateHash = sha256Utf8(coordinateKey);
+        const discriminator = mutationDiscriminator(input)
+            ?? generationDiscriminator(input.coordinateGeneration);
+        if (!discriminator)
+            return null;
+        return identityFromKey([
+            "bb-sem-v1",
+            providerNamespace,
+            "reaction",
+            eventGuid,
+            targetGuid,
+            actorIdentityHash,
+            canonicalValue,
+            canonicalAction,
+            discriminator,
+        ], true, discriminator, coordinateKey, coordinateHash);
+    }
+    if (input.kind === "edit") {
+        const messageGuid = requiredIdentifier(input.eventGuid);
+        if (!messageGuid)
+            return null;
+        const discriminator = mutationDiscriminator(input)
+            ?? (typeof input.text === "string" ? `content:${sha256Utf8(input.text)}` : null);
+        if (!discriminator)
+            return null;
+        return identityFromKey(["bb-sem-v1", providerNamespace, "edit", messageGuid, discriminator], true, discriminator);
+    }
+    if (input.kind === "unsend") {
+        const targetGuid = requiredIdentifier(input.targetGuid);
+        if (!targetGuid)
+            return null;
+        const discriminator = mutationDiscriminator(input) ?? "terminal";
+        return identityFromKey(["bb-sem-v1", providerNamespace, "unsend", targetGuid, discriminator], true, discriminator);
+    }
+    const eventGuid = requiredIdentifier(input.eventGuid);
+    if (!eventGuid)
+        return null;
+    const discriminator = effectiveTimestampDiscriminator(input.effectiveTimestamp) ?? "terminal";
+    return identityFromKey(["bb-sem-v1", providerNamespace, "audit", input.kind, eventGuid, discriminator], false, discriminator);
+}
+function buildBlueBubblesSemanticCapture(input) {
+    if (typeof input.event.fromMe !== "boolean")
+        return null;
+    const providerNamespace = normalizeProviderNamespace(input.cutover.providerNamespace);
+    const capturedAt = exactIsoMilliseconds(input.capturedAt);
+    const sender = input.event.sender;
+    const actorExternalId = sender.observed === true
+        ? requiredIdentifier(sender.externalId)
+        : null;
+    if (!providerNamespace || !capturedAt || !actorExternalId)
+        return null;
+    const inputObservationEpoch = input.observationEpoch;
+    const inputObservationOrdinal = input.observationOrdinal;
+    const observationClock = inputObservationEpoch === undefined
+        && inputObservationOrdinal === undefined
+        ? null
+        : isBlueBubblesObservationEpoch(inputObservationEpoch)
+            && typeof inputObservationOrdinal === "number"
+            && Number.isSafeInteger(inputObservationOrdinal)
+            && inputObservationOrdinal > 0
+            ? {
+                observationEpoch: inputObservationEpoch,
+                observationOrdinal: inputObservationOrdinal,
+            }
+            : false;
+    if (observationClock === false)
+        return null;
+    const kind = input.event.kind === "message" ? "message" : input.event.mutationType;
+    const eventGuid = requiredIdentifier(input.event.messageGuid);
+    const targetGuid = input.event.kind === "mutation"
+        ? requiredIdentifier(input.event.targetMessageGuid)
+            ?? (input.event.mutationType === "unsend" ? eventGuid : null)
+        : null;
+    const reaction = input.event.kind === "mutation" ? input.event.reaction : undefined;
+    const editedText = input.event.kind === "mutation" ? input.event.editedText : undefined;
+    const identity = buildBlueBubblesSemanticIdentity({
+        providerNamespace,
+        kind,
+        eventGuid,
+        targetGuid,
+        actorExternalId,
+        canonicalValue: reaction?.canonicalValue,
+        canonicalAction: reaction?.action,
+        revision: input.event.kind === "mutation" ? input.event.revision : undefined,
+        effectiveTimestamp: input.event.kind === "mutation" ? input.event.effectiveTimestamp : undefined,
+        text: input.event.kind === "message" ? input.event.text : editedText,
+        coordinateGeneration: input.coordinateGeneration,
+    });
+    if (!identity)
+        return null;
+    const text = input.event.kind === "message"
+        ? input.event.text
+        : kind === "edit" ? editedText ?? null : null;
+    const textSha256 = text === null ? null : sha256Utf8(text);
+    const effectiveAt = input.event.kind === "mutation"
+        ? finiteTimestampIso(input.event.effectiveTimestamp)
+        : null;
+    const revision = input.event.kind === "mutation"
+        ? normalizedRevision(input.event.revision)
+        : null;
+    const participants = normalizeIngressParticipants(input.event.chat.participantHandles.map((externalId) => ({
+        provider: "imessage-handle",
+        externalId,
+        displayName: null,
+    })));
+    const capture = {
+        schemaVersion: 1,
+        canonicalKey: identity.canonicalKey,
+        keyHash: identity.keyHash,
+        providerNamespace,
+        capturedAt,
+        event: {
+            provider: "bluebubbles",
+            kind,
+            eventGuid,
+            fromMe: input.event.fromMe,
+            actor: {
+                provider: "imessage-handle",
+                externalId: actorExternalId,
+                displayName: normalizeDisplayName(sender.displayName),
+            },
+            participants,
+            sourceEventType: input.event.eventType,
+            sessionKey: nullableString(input.event.chat.sessionKey),
+            chatGuid: nullableString(input.event.chat.chatGuid),
+            chatIdentifier: nullableString(input.event.chat.chatIdentifier),
+            text,
+            textSha256,
+            targetGuid,
+            targetAuthorship: input.targetAuthorship,
+            canonicalAction: reaction?.action ?? null,
+            canonicalValue: reaction?.canonicalValue ?? null,
+            rawTransportValue: reaction?.rawTransportValue ?? null,
+            effectiveAt,
+            revision,
+            contentSha256: kind === "edit" ? textSha256 : null,
+        },
+    };
+    if (observationClock) {
+        attachBlueBubblesSemanticObservationOrder(capture, {
+            schemaVersion: 1,
+            keyHash: capture.keyHash,
+            captureHash: blueBubblesSemanticCaptureHash(capture),
+            observedAt: capturedAt,
+            ...observationClock,
+        });
+    }
+    return capture;
+}
+function buildBlueBubblesReactionCoordinateRecord(input) {
+    return {
+        schemaVersion: 1,
+        coordinateKey: input.coordinateKey,
+        coordinateHash: input.coordinateHash,
+        generation: input.generation,
+        lastAction: input.lastAction,
+        updatedAt: input.updatedAt,
+    };
+}
+function buildBlueBubblesSemanticClaimRecord(input) {
+    return {
+        schemaVersion: 1,
+        canonicalKey: input.canonicalKey,
+        keyHash: input.keyHash,
+        owner: {
+            operationId: input.operationId,
+            pid: input.pid,
+            bootIdentity: input.bootIdentity,
+            processStartedAt: input.processStartedAt,
+            acquiredAt: input.acquiredAt,
+        },
+    };
+}
+function classifyBlueBubblesRecoveryRecord(value, cutover) {
+    if (!isRecord(value) || value.schemaVersion !== 1) {
+        emitLegacyRecoveryBlocked(value);
+        return { disposition: "audit_only", reason: "legacy_or_actorless" };
+    }
+    if (!isRecord(value.event)) {
+        emitInvalidSemanticRecoveryRecord(value, false, "event_missing");
+        return { disposition: "audit_only", reason: "legacy_or_actorless" };
+    }
+    const actor = value.event.actor;
+    if (!isRecord(actor)
+        || actor.provider !== "imessage-handle"
+        || typeof actor.externalId !== "string"
+        || actor.externalId.trim().length === 0) {
+        emitInvalidSemanticRecoveryRecord(value, false, "actor_missing");
+        return { disposition: "audit_only", reason: "legacy_or_actorless" };
+    }
+    if (value.providerNamespace !== cutover.providerNamespace
+        || typeof value.capturedAt !== "string"
+        || !exactIsoMilliseconds(value.capturedAt)
+        || value.capturedAt < cutover.effectiveAt) {
+        return { disposition: "audit_only", reason: "before_cutover" };
+    }
+    if (value.event.kind === "read" || value.event.kind === "delivery") {
+        return { disposition: "audit_only", reason: "audit_event" };
+    }
+    if (typeof value.keyHash !== "string" || value.keyHash.length === 0) {
+        emitInvalidSemanticRecoveryRecord(value, true, "key_hash_missing");
+        return { disposition: "audit_only", reason: "legacy_or_actorless" };
+    }
+    return { disposition: "handleable", keyHash: value.keyHash };
+}
+function writeBlueBubblesSemanticCapture(agentName, capture, deps = {}) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "bluebubbles_semantic_capture_start",
+        message: "publishing bluebubbles semantic capture",
+        meta: { agentName, keyHash: capture.keyHash },
+    });
+    try {
+        const paths = getBlueBubblesSemanticPaths(agentName);
+        const finalPath = semanticRecordPath(paths.captures, capture.keyHash);
+        const validCapture = isBlueBubblesSemanticCapture(capture, capture.keyHash);
+        const existing = readExistingCaptureForWrite(agentName, capture.keyHash, deps);
+        if (existing) {
+            if (validCapture && capturesAreEquivalent(existing, capture)) {
+                persistBlueBubblesSemanticObservationOrder(agentName, capture, deps);
+            }
+            return finishCaptureComparison(agentName, existing, capture, deps);
+        }
+        if (!validCapture)
+            throw semanticStoreError("semantic_capture_invalid");
+        persistBlueBubblesSemanticObservationOrder(agentName, capture, deps);
+        const publication = publishImmutableSemanticRecord(paths.captures, finalPath, capture, deps);
+        if (publication === "exists") {
+            const winner = readExistingCaptureForWrite(agentName, capture.keyHash, deps);
+            if (!winner) {
+                return writeBlueBubblesSemanticCaptureAfterQuarantine(agentName, capture, deps);
+            }
+            return finishCaptureComparison(agentName, winner, capture, deps);
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "bluebubbles_semantic_capture_end",
+            message: "published bluebubbles semantic capture",
+            meta: { agentName, keyHash: capture.keyHash, result: "semantic_capture_published" },
+        });
+        return "semantic_capture_published";
+    }
+    catch (error) {
+        emitCaptureError(agentName, capture.keyHash, error);
+        throw semanticStoreError("semantic_capture_failed", error);
+    }
+}
+function readBlueBubblesSemanticCapture(agentName, keyHash, deps = {}) {
+    const paths = getBlueBubblesSemanticPaths(agentName);
+    const finalPath = semanticRecordPath(paths.captures, keyHash);
+    const capture = readSemanticRecord(finalPath, "capture", keyHash, (value) => isBlueBubblesSemanticCapture(value, keyHash), deps);
+    return capture ? attachStoredBlueBubblesSemanticObservationOrder(paths, capture, deps) : null;
+}
+function readBlueBubblesSemanticCaptureAtRoot(agentRoot, keyHash, deps = {}) {
+    const paths = getBlueBubblesSemanticPathsAtRoot(agentRoot);
+    const finalPath = semanticRecordPath(paths.captures, keyHash);
+    const capture = readSemanticRecord(finalPath, "capture", keyHash, (value) => isBlueBubblesSemanticCapture(value, keyHash), deps);
+    return capture ? attachStoredBlueBubblesSemanticObservationOrder(paths, capture, deps) : null;
+}
+function listPendingBlueBubblesSemanticCaptures(agentName, deps = {}) {
+    const storeFs = semanticFs(deps);
+    const paths = getBlueBubblesSemanticPaths(agentName);
+    if (!storeFs.existsSync(paths.captures))
+        return [];
+    const captures = [];
+    const names = storeFs.readdirSync(paths.captures)
+        .filter((name) => /^[0-9a-f]{64}\.json$/.test(name))
+        .sort();
+    for (const name of names) {
+        const keyHash = name.slice(0, -".json".length);
+        const capture = readBlueBubblesSemanticCapture(agentName, keyHash, deps);
+        if (!capture)
+            continue;
+        if (readBlueBubblesSemanticHandled(agentName, keyHash, deps))
+            continue;
+        captures.push(capture);
+    }
+    return captures.sort((left, right) => (compareBlueBubblesSemanticCaptureOrder(left, right)));
+}
+function compareBlueBubblesSemanticCaptureOrder(left, right) {
+    if (left.observationEpoch !== undefined
+        && left.observationEpoch === right.observationEpoch
+        && left.observationOrdinal !== undefined
+        && right.observationOrdinal !== undefined
+        && left.observationOrdinal !== right.observationOrdinal) {
+        return left.observationOrdinal - right.observationOrdinal;
+    }
+    const capturedOrder = (left.observationObservedAt ?? left.capturedAt)
+        .localeCompare(right.observationObservedAt ?? right.capturedAt);
+    if (capturedOrder !== 0)
+        return capturedOrder;
+    if (left.observationEpoch === undefined && right.observationEpoch === undefined)
+        return 0;
+    const epochOrder = (left.observationEpoch ?? "").localeCompare(right.observationEpoch ?? "");
+    if (epochOrder !== 0)
+        return epochOrder;
+    return left.keyHash.localeCompare(right.keyHash);
+}
+function attachBlueBubblesSemanticObservationOrder(capture, order) {
+    Object.defineProperties(capture, {
+        observationObservedAt: {
+            configurable: true,
+            enumerable: false,
+            value: order.observedAt,
+        },
+        observationEpoch: {
+            configurable: true,
+            enumerable: false,
+            value: order.observationEpoch,
+        },
+        observationOrdinal: {
+            configurable: true,
+            enumerable: false,
+            value: order.observationOrdinal,
+        },
+    });
+    return capture;
+}
+function blueBubblesSemanticObservationOrderFromCapture(capture) {
+    if (!isBlueBubblesObservationEpoch(capture.observationEpoch)
+        || typeof capture.observationOrdinal !== "number"
+        || !Number.isSafeInteger(capture.observationOrdinal)
+        || capture.observationOrdinal <= 0)
+        return null;
+    return {
+        schemaVersion: 1,
+        keyHash: capture.keyHash,
+        captureHash: blueBubblesSemanticCaptureHash(capture),
+        observedAt: capture.capturedAt,
+        observationEpoch: capture.observationEpoch,
+        observationOrdinal: capture.observationOrdinal,
+    };
+}
+function compareBlueBubblesSemanticObservationOrders(left, right) {
+    if (left.observationEpoch === right.observationEpoch
+        && left.observationOrdinal !== right.observationOrdinal) {
+        return left.observationOrdinal - right.observationOrdinal;
+    }
+    const observedOrder = left.observedAt.localeCompare(right.observedAt);
+    if (observedOrder !== 0)
+        return observedOrder;
+    const epochOrder = left.observationEpoch.localeCompare(right.observationEpoch);
+    if (epochOrder !== 0)
+        return epochOrder;
+    return left.observationOrdinal - right.observationOrdinal;
+}
+function persistBlueBubblesSemanticObservationOrder(agentName, capture, deps) {
+    const candidate = blueBubblesSemanticObservationOrderFromCapture(capture);
+    if (!candidate)
+        return;
+    const paths = getBlueBubblesSemanticPaths(agentName);
+    const finalPath = semanticRecordPath(paths.observationOrders, candidate.captureHash);
+    const startedAt = semanticNow(deps).getTime();
+    while (true) {
+        const result = withExclusiveSemanticOwnership(paths.ownership, deps, () => {
+            const inspected = inspectSemanticRecord(finalPath, capture.keyHash, (value) => (isBlueBubblesSemanticObservationOrderRecord(value, capture.keyHash, candidate.captureHash)), deps);
+            if (inspected.status === "valid") {
+                if (compareBlueBubblesSemanticObservationOrders(inspected.value, candidate) <= 0) {
+                    fsyncSemanticDirectory(paths.observationOrders, semanticFs(deps));
+                    return;
+                }
+            }
+            else if (inspected.status === "invalid") {
+                quarantineSemanticRecord(finalPath, "observation-order", capture.keyHash, deps, inspected.reason);
+            }
+            writeMutableSemanticRecord(paths.observationOrders, finalPath, candidate, deps);
+        });
+        if (result.status === "completed")
+            return;
+        if (semanticNow(deps).getTime() - startedAt >= SEMANTIC_CLAIM_TIMEOUT_MS) {
+            throw semanticStoreError("semantic_ownership_busy");
+        }
+        semanticSleepSync(SEMANTIC_CLAIM_POLL_MS, deps);
+    }
+}
+function attachStoredBlueBubblesSemanticObservationOrder(paths, capture, deps) {
+    const captureHash = blueBubblesSemanticCaptureHash(capture);
+    const finalPath = semanticRecordPath(paths.observationOrders, captureHash);
+    const order = readSemanticRecord(finalPath, "observation-order", capture.keyHash, (value) => (isBlueBubblesSemanticObservationOrderRecord(value, capture.keyHash, captureHash)), deps);
+    return order ? attachBlueBubblesSemanticObservationOrder(capture, order) : capture;
+}
+function writeBlueBubblesSemanticHandled(agentName, record, deps = {}) {
+    try {
+        const paths = getBlueBubblesSemanticPaths(agentName);
+        const finalPath = semanticRecordPath(paths.handled, record.keyHash);
+        const existing = readExistingHandledForWrite(agentName, record.keyHash, deps);
+        if (existing)
+            return finishHandledComparison(agentName, existing, record, deps);
+        if (!isBlueBubblesSemanticHandledRecord(record, record.keyHash)) {
+            throw semanticStoreError("semantic_handled_invalid");
+        }
+        const publication = publishImmutableSemanticRecord(paths.handled, finalPath, record, deps);
+        if (publication === "exists") {
+            const winner = readExistingHandledForWrite(agentName, record.keyHash, deps);
+            if (!winner)
+                return writeBlueBubblesSemanticHandled(agentName, record, deps);
+            return finishHandledComparison(agentName, winner, record, deps);
+        }
+        return "semantic_handled_published";
+    }
+    catch (error) {
+        emitSemanticStoreError(agentName, record.keyHash, "semantic_handled_failed", error);
+        if (error instanceof Error && error.message === "semantic_handled_failed")
+            throw error;
+        throw semanticStoreError("semantic_handled_failed", error);
+    }
+}
+function readBlueBubblesSemanticHandled(agentName, keyHash, deps = {}) {
+    const paths = getBlueBubblesSemanticPaths(agentName);
+    const finalPath = semanticRecordPath(paths.handled, keyHash);
+    return readSemanticRecord(finalPath, "handled", keyHash, (value) => isBlueBubblesSemanticHandledRecord(value, keyHash), deps);
+}
+async function acquireBlueBubblesSemanticClaim(agentName, identity, deps = {}) {
+    const keyHash = validatedKeyHash(identity.keyHash);
+    if (sha256Utf8(identity.canonicalKey) !== keyHash) {
+        throw semanticStoreError("semantic_claim_invalid");
+    }
+    const handled = readBlueBubblesSemanticHandled(agentName, identity.keyHash, deps);
+    if (handled)
+        return { status: "already_handled", record: handled };
+    const paths = getBlueBubblesSemanticPaths(agentName);
+    const ownerPath = path.join(paths.claims, `${validatedKeyHash(identity.keyHash)}.owner.json`);
+    let ownerResult;
+    try {
+        ownerResult = await acquireExclusiveSemanticOwner({
+            directoryPath: paths.claims,
+            ownerPath,
+            canonicalKey: identity.canonicalKey,
+            keyHash: identity.keyHash,
+            operationId: `semantic-handle:${identity.keyHash}`,
+            recordKind: "claim",
+            ownershipPath: paths.ownership,
+            resourceKey: `claim:${keyHash}`,
+        }, deps);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "semantic_owner_liveness_failed") {
+            throw semanticStoreError("semantic_claim_liveness_failed", error);
+        }
+        throw error;
+    }
+    if (ownerResult.status === "timeout") {
+        return { status: "timeout", code: "semantic_claim_timeout" };
+    }
+    const lease = { status: "acquired", record: ownerResult.record };
+    semanticClaimLeaseIds.set(lease, ownerResult.leaseId);
+    const handledAfterClaim = readBlueBubblesSemanticHandled(agentName, identity.keyHash, deps);
+    if (handledAfterClaim) {
+        releaseBlueBubblesSemanticClaim(agentName, lease, deps);
+        return { status: "already_handled", record: handledAfterClaim };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "bluebubbles_semantic_recovery_claimed",
+        message: "claimed captured bluebubbles semantic event",
+        meta: { schemaVersion: 1, actorPresent: true, keyHash: identity.keyHash },
+    });
+    return lease;
+}
+function releaseBlueBubblesSemanticClaim(agentName, lease, deps = {}) {
+    const paths = getBlueBubblesSemanticPaths(agentName);
+    const ownerPath = path.join(paths.claims, `${validatedKeyHash(lease.record.keyHash)}.owner.json`);
+    const leaseId = semanticClaimLeaseIds.get(lease);
+    if (!leaseId)
+        return false;
+    return releaseExclusiveSemanticOwner({
+        directoryPath: paths.claims,
+        ownerPath,
+        ownershipPath: paths.ownership,
+        resourceKey: `claim:${lease.record.keyHash}`,
+        record: lease.record,
+        leaseId,
+    }, deps);
+}
+async function allocateBlueBubblesReactionCoordinate(agentName, input, deps = {}) {
+    const coordinateHash = validatedKeyHash(input.coordinateHash);
+    if (sha256Utf8(input.coordinateKey) !== coordinateHash || !CANONICAL_ACTIONS.has(input.canonicalAction)) {
+        throw semanticStoreError("semantic_coordinate_invalid");
+    }
+    const paths = getBlueBubblesSemanticPaths(agentName);
+    const finalPath = path.join(paths.coordinates, `${coordinateHash}.json`);
+    const ownerPath = path.join(paths.coordinates, `${coordinateHash}.owner.lock`);
+    if (hasSemanticQuarantine(paths.quarantine, "coordinate", path.basename(finalPath), deps)) {
+        throw semanticStoreError("semantic_coordinate_invalid");
+    }
+    let ownerResult;
+    try {
+        ownerResult = await acquireExclusiveSemanticOwner({
+            directoryPath: paths.coordinates,
+            ownerPath,
+            canonicalKey: input.coordinateKey,
+            keyHash: coordinateHash,
+            operationId: `semantic-coordinate:${coordinateHash}`,
+            recordKind: "coordinate-owner",
+            ownershipPath: paths.ownership,
+            resourceKey: `coordinate:${coordinateHash}`,
+        }, deps);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "semantic_owner_liveness_failed") {
+            throw semanticStoreError("semantic_coordinate_liveness_failed", error);
+        }
+        throw error;
+    }
+    if (ownerResult.status === "timeout") {
+        throw semanticStoreError("semantic_coordinate_lock_timeout");
+    }
+    try {
+        if (hasSemanticQuarantine(paths.quarantine, "coordinate", path.basename(finalPath), deps)) {
+            throw semanticStoreError("semantic_coordinate_invalid");
+        }
+        const existing = readSemanticRecord(finalPath, "coordinate", coordinateHash, (value) => isBlueBubblesReactionCoordinateRecord(value, input.coordinateKey, coordinateHash), deps);
+        if (!existing && hasSemanticQuarantine(paths.quarantine, "coordinate", path.basename(finalPath), deps)) {
+            throw semanticStoreError("semantic_coordinate_invalid");
+        }
+        if (existing && existing.lastAction === input.canonicalAction) {
+            fsyncSemanticDirectory(paths.coordinates, semanticFs(deps));
+            return existing;
+        }
+        const record = buildBlueBubblesReactionCoordinateRecord({
+            coordinateKey: input.coordinateKey,
+            coordinateHash,
+            generation: existing ? existing.generation + 1 : 0,
+            lastAction: input.canonicalAction,
+            updatedAt: semanticNow(deps).toISOString(),
+        });
+        writeMutableSemanticRecord(paths.coordinates, finalPath, record, deps);
+        return record;
+    }
+    finally {
+        releaseExclusiveSemanticOwner({
+            directoryPath: paths.coordinates,
+            ownerPath,
+            ownershipPath: paths.ownership,
+            resourceKey: `coordinate:${coordinateHash}`,
+            record: ownerResult.record,
+            leaseId: ownerResult.leaseId,
+        }, deps);
+    }
+}
+function writeBlueBubblesSemanticCaptureAfterQuarantine(agentName, capture, deps) {
+    const paths = getBlueBubblesSemanticPaths(agentName);
+    const finalPath = semanticRecordPath(paths.captures, capture.keyHash);
+    const publication = publishImmutableSemanticRecord(paths.captures, finalPath, capture, deps);
+    if (publication === "exists") {
+        const winner = readExistingCaptureForWrite(agentName, capture.keyHash, deps);
+        if (!winner)
+            throw semanticStoreError("semantic_capture_failed");
+        return finishCaptureComparison(agentName, winner, capture, deps);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "bluebubbles_semantic_capture_end",
+        message: "published bluebubbles semantic capture after quarantining invalid state",
+        meta: { agentName, keyHash: capture.keyHash, result: "semantic_capture_published" },
+    });
+    return "semantic_capture_published";
+}
+function readExistingCaptureForWrite(agentName, keyHash, deps) {
+    const paths = getBlueBubblesSemanticPaths(agentName);
+    const finalPath = semanticRecordPath(paths.captures, keyHash);
+    return semanticFs(deps).existsSync(finalPath)
+        ? readBlueBubblesSemanticCapture(agentName, keyHash, deps)
+        : null;
+}
+function finishCaptureComparison(agentName, existing, candidate, deps) {
+    fsyncSemanticDirectory(getBlueBubblesSemanticPaths(agentName).captures, semanticFs(deps));
+    if (capturesAreEquivalent(existing, candidate)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "bluebubbles_semantic_capture_end",
+            message: "recognized duplicate bluebubbles semantic capture",
+            meta: { agentName, keyHash: candidate.keyHash, result: "semantic_capture_duplicate" },
+        });
+        return "semantic_capture_duplicate";
+    }
+    const error = semanticStoreError("semantic_identity_collision");
+    emitCaptureError(agentName, candidate.keyHash, error);
+    return "semantic_identity_collision";
+}
+function readExistingHandledForWrite(agentName, keyHash, deps) {
+    const paths = getBlueBubblesSemanticPaths(agentName);
+    const finalPath = semanticRecordPath(paths.handled, keyHash);
+    return semanticFs(deps).existsSync(finalPath)
+        ? readBlueBubblesSemanticHandled(agentName, keyHash, deps)
+        : null;
+}
+function finishHandledComparison(agentName, existing, candidate, deps) {
+    fsyncSemanticDirectory(getBlueBubblesSemanticPaths(agentName).handled, semanticFs(deps));
+    if (handledRecordsAreEquivalent(existing, candidate))
+        return "semantic_handled_duplicate";
+    emitSemanticStoreError(agentName, candidate.keyHash, "semantic_handled_collision", semanticStoreError("semantic_handled_collision"));
+    return "semantic_handled_collision";
+}
+function capturesAreEquivalent(left, right) {
+    return blueBubblesSemanticCaptureHash(left) === blueBubblesSemanticCaptureHash(right);
+}
+function blueBubblesSemanticCaptureHash(capture) {
+    const projection = {
+        schemaVersion: capture.schemaVersion,
+        canonicalKey: capture.canonicalKey,
+        keyHash: capture.keyHash,
+        providerNamespace: capture.providerNamespace,
+        event: {
+            provider: capture.event.provider,
+            kind: capture.event.kind,
+            eventGuid: capture.event.eventGuid,
+            fromMe: capture.event.fromMe,
+            actor: capture.event.actor,
+            participants: capture.event.participants,
+            text: capture.event.text,
+            textSha256: capture.event.textSha256,
+            targetGuid: capture.event.targetGuid,
+            targetAuthorship: capture.event.targetAuthorship,
+            canonicalAction: capture.event.canonicalAction,
+            canonicalValue: capture.event.canonicalValue,
+            effectiveAt: capture.event.effectiveAt,
+            revision: capture.event.revision,
+            contentSha256: capture.event.contentSha256,
+        },
+    };
+    return sha256Utf8(JSON.stringify(projection));
+}
+function handledRecordsAreEquivalent(left, right) {
+    const project = (record) => ({
+        schemaVersion: record.schemaVersion,
+        canonicalKey: record.canonicalKey,
+        keyHash: record.keyHash,
+        outcome: record.outcome,
+        detailCode: record.detailCode,
+    });
+    return JSON.stringify(project(left)) === JSON.stringify(project(right));
+}
+function publishImmutableSemanticRecord(directoryPath, finalPath, value, deps) {
+    const storeFs = semanticFs(deps);
+    storeFs.mkdirSync(directoryPath, { recursive: true });
+    const tempPath = semanticTempPath(finalPath, deps);
+    let tempFd = null;
+    let tempOwned = false;
+    let outcome = null;
+    let primaryError;
+    try {
+        tempFd = storeFs.openSync(tempPath, "wx", 0o600);
+        tempOwned = true;
+        storeFs.writeFileSync(tempFd, serializeBlueBubblesSemanticJson(value), "utf8");
+        storeFs.fsyncSync(tempFd);
+        storeFs.closeSync(tempFd);
+        tempFd = null;
+        try {
+            storeFs.linkSync(tempPath, finalPath);
+            fsyncSemanticDirectory(directoryPath, storeFs);
+            outcome = "published";
+        }
+        catch (error) {
+            if (!isNodeError(error, "EEXIST"))
+                throw error;
+            outcome = "exists";
+        }
+    }
+    catch (error) {
+        primaryError = error;
+    }
+    let cleanupError;
+    if (tempFd !== null) {
+        try {
+            storeFs.closeSync(tempFd);
+        }
+        catch (error) {
+            cleanupError = error;
+        }
+    }
+    if (tempOwned) {
+        try {
+            storeFs.unlinkSync(tempPath);
+        }
+        catch (error) {
+            if (!isNodeError(error, "ENOENT") && cleanupError === undefined)
+                cleanupError = error;
+        }
+    }
+    if (primaryError !== undefined)
+        throw primaryError;
+    if (cleanupError !== undefined)
+        throw cleanupError;
+    return outcome;
+}
+function writeMutableSemanticRecord(directoryPath, finalPath, value, deps) {
+    const storeFs = semanticFs(deps);
+    storeFs.mkdirSync(directoryPath, { recursive: true });
+    const tempPath = semanticTempPath(finalPath, deps);
+    let tempFd = null;
+    let tempOwned = false;
+    let primaryError;
+    try {
+        tempFd = storeFs.openSync(tempPath, "wx", 0o600);
+        tempOwned = true;
+        storeFs.writeFileSync(tempFd, serializeBlueBubblesSemanticJson(value), "utf8");
+        storeFs.fsyncSync(tempFd);
+        storeFs.closeSync(tempFd);
+        tempFd = null;
+        storeFs.renameSync(tempPath, finalPath);
+        fsyncSemanticDirectory(directoryPath, storeFs);
+    }
+    catch (error) {
+        primaryError = error;
+    }
+    let cleanupError;
+    if (tempFd !== null) {
+        try {
+            storeFs.closeSync(tempFd);
+        }
+        catch (error) {
+            cleanupError = error;
+        }
+    }
+    if (tempOwned) {
+        try {
+            storeFs.unlinkSync(tempPath);
+        }
+        catch (error) {
+            if (!isNodeError(error, "ENOENT") && cleanupError === undefined)
+                cleanupError = error;
+        }
+    }
+    if (primaryError !== undefined)
+        throw primaryError;
+    if (cleanupError !== undefined)
+        throw cleanupError;
+}
+async function acquireExclusiveSemanticOwner(input, deps) {
+    const keyHash = validatedKeyHash(input.keyHash);
+    const pid = semanticPid(deps);
+    const ownerRecord = buildBlueBubblesSemanticClaimRecord({
+        canonicalKey: input.canonicalKey,
+        keyHash,
+        operationId: input.operationId,
+        pid,
+        bootIdentity: semanticBootIdentity(deps),
+        processStartedAt: requiredProbeIdentity(semanticProcessStartedAt(pid, deps)),
+        acquiredAt: nextOwnerAcquiredAt(input.ownerPath, deps),
+    });
+    const leaseId = semanticRandomUuid(deps);
+    const startedAt = semanticNow(deps).getTime();
+    while (true) {
+        const attempt = withExclusiveSemanticOwnership(input.ownershipPath, deps, (database) => acquireSemanticOwnerInTransaction(database, input, ownerRecord, leaseId, deps));
+        if (attempt.status === "completed" && attempt.value === "acquired") {
+            return { status: "acquired", record: ownerRecord, leaseId };
+        }
+        if (semanticNow(deps).getTime() - startedAt >= SEMANTIC_CLAIM_TIMEOUT_MS) {
+            return { status: "timeout" };
+        }
+        await semanticSleep(SEMANTIC_CLAIM_POLL_MS, deps);
+    }
+}
+function releaseExclusiveSemanticOwner(input, deps) {
+    const startedAt = semanticNow(deps).getTime();
+    while (true) {
+        const result = withExclusiveSemanticOwnership(input.ownershipPath, deps, (database) => {
+            const row = readSemanticOwnershipRow(database, input.resourceKey);
+            if (!row || row.lease_id !== input.leaseId)
+                return false;
+            const rowOwner = parseSemanticOwnershipRow(row, {
+                canonicalKey: input.record.canonicalKey,
+                keyHash: input.record.keyHash,
+                operationId: input.record.owner.operationId,
+            });
+            if (serializeBlueBubblesSemanticJson(rowOwner) !== serializeBlueBubblesSemanticJson(input.record)) {
+                return false;
+            }
+            const evidence = inspectSemanticOwnerEvidence(input.ownerPath, {
+                canonicalKey: input.record.canonicalKey,
+                keyHash: input.record.keyHash,
+                operationId: input.record.owner.operationId,
+            }, deps);
+            if (evidence.status === "invalid")
+                return false;
+            if (evidence.status === "valid" && evidence.bytes !== row.owner_json)
+                return false;
+            if (evidence.status === "valid" && !removeSemanticOwnerEvidenceIfUnchanged(input.directoryPath, input.ownerPath, row.owner_json, semanticFs(deps)))
+                return false;
+            deleteSemanticOwnershipRow(database, input.resourceKey, input.leaseId);
+            return true;
+        });
+        if (result.status === "completed")
+            return result.value;
+        if (semanticNow(deps).getTime() - startedAt >= SEMANTIC_CLAIM_TIMEOUT_MS) {
+            throw semanticStoreError("semantic_ownership_busy");
+        }
+        semanticSleepSync(SEMANTIC_CLAIM_POLL_MS, deps);
+    }
+}
+function removeSemanticOwnerEvidenceIfUnchanged(directoryPath, ownerPath, expectedBytes, storeFs) {
+    let before;
+    try {
+        before = storeFs.lstatSync(ownerPath);
+    }
+    catch (error) {
+        if (isNodeError(error, "ENOENT"))
+            return false;
+        throw error;
+    }
+    let current;
+    try {
+        current = storeFs.readFileSync(ownerPath, "utf8");
+    }
+    catch (error) {
+        if (isNodeError(error, "ENOENT"))
+            return false;
+        throw error;
+    }
+    const after = storeFs.lstatSync(ownerPath);
+    if (!before.isFile()
+        || !after.isFile()
+        || before.dev !== after.dev
+        || before.ino !== after.ino
+        || current !== expectedBytes)
+        return false;
+    storeFs.unlinkSync(ownerPath);
+    fsyncSemanticDirectory(directoryPath, storeFs);
+    return true;
+}
+function withExclusiveSemanticOwnership(ownershipPath, deps, operation) {
+    const storeFs = semanticFs(deps);
+    storeFs.mkdirSync(path.dirname(ownershipPath), { recursive: true });
+    let database = null;
+    try {
+        database = new better_sqlite3_1.default(ownershipPath, { timeout: 0 });
+        database.pragma("busy_timeout = 0");
+        database.pragma("journal_mode = DELETE");
+        database.pragma("synchronous = FULL");
+        database.exec("BEGIN EXCLUSIVE");
+        initializeSemanticOwnershipSchema(database);
+        fsyncSemanticDirectory(path.dirname(ownershipPath), storeFs);
+        const value = operation(database);
+        database.exec("COMMIT");
+        return { status: "completed", value };
+    }
+    catch (error) {
+        if (database?.inTransaction) {
+            database.exec("ROLLBACK");
+        }
+        if (isSqliteBusy(error))
+            return { status: "busy" };
+        if (isSqliteError(error))
+            throw semanticStoreError("semantic_ownership_invalid", error);
+        throw error;
+    }
+    finally {
+        database?.close();
+    }
+}
+function initializeSemanticOwnershipSchema(database) {
+    const version = database.pragma("user_version", { simple: true });
+    if (version === 0) {
+        database.exec(SEMANTIC_OWNERSHIP_SCHEMA_SQL);
+        database.pragma(`user_version = ${SEMANTIC_OWNERSHIP_SCHEMA_VERSION}`);
+    }
+    else if (version !== SEMANTIC_OWNERSHIP_SCHEMA_VERSION) {
+        throw semanticStoreError("semantic_ownership_invalid");
+    }
+    const schema = database.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'owner_leases'").get();
+    if (schema?.sql !== SEMANTIC_OWNERSHIP_SCHEMA_SQL) {
+        throw semanticStoreError("semantic_ownership_invalid");
+    }
+}
+function acquireSemanticOwnerInTransaction(database, input, candidate, leaseId, deps) {
+    const row = readSemanticOwnershipRow(database, input.resourceKey);
+    if (row) {
+        const existing = parseSemanticOwnershipRow(row, input);
+        if (!semanticOwnerIsStale(existing, deps)) {
+            reconcileSemanticOwnerEvidence(input, existing, deps);
+            return "occupied";
+        }
+        quarantineSemanticOwnerEvidenceIfPresent(input, deps);
+        deleteSemanticOwnershipRow(database, input.resourceKey, row.lease_id);
+    }
+    else {
+        const evidence = inspectSemanticOwnerEvidence(input.ownerPath, input, deps);
+        if (evidence.status === "valid" && !semanticOwnerIsStale(evidence.record, deps)) {
+            insertSemanticOwnershipRow(database, input.resourceKey, semanticRandomUuid(deps), evidence.bytes);
+            return "occupied";
+        }
+        if (evidence.status !== "missing") {
+            quarantineSemanticRecord(input.ownerPath, input.recordKind, input.keyHash, deps, evidence.status === "invalid"
+                ? evidence.reason
+                : semanticStoreError("semantic_owner_stale"));
+        }
+    }
+    const ownerJson = serializeBlueBubblesSemanticJson(candidate);
+    insertSemanticOwnershipRow(database, input.resourceKey, leaseId, ownerJson);
+    ensureSemanticOwnerEvidence(input, candidate, ownerJson, deps);
+    return "acquired";
+}
+function readSemanticOwnershipRow(database, resourceKey) {
+    return database.prepare("SELECT resource_key, lease_id, owner_json FROM owner_leases WHERE resource_key = ?").get(resourceKey) ?? null;
+}
+function insertSemanticOwnershipRow(database, resourceKey, leaseId, ownerJson) {
+    database.prepare("INSERT INTO owner_leases (resource_key, lease_id, owner_json) VALUES (?, ?, ?)").run(resourceKey, leaseId, ownerJson);
+}
+function deleteSemanticOwnershipRow(database, resourceKey, leaseId) {
+    database.prepare("DELETE FROM owner_leases WHERE resource_key = ? AND lease_id = ?").run(resourceKey, leaseId);
+}
+function parseSemanticOwnershipRow(row, expected) {
+    if (!UUID_V4_PATTERN.test(row.lease_id)) {
+        throw semanticStoreError("semantic_ownership_invalid");
+    }
+    let value;
+    try {
+        value = JSON.parse(row.owner_json);
+    }
+    catch (error) {
+        throw semanticStoreError("semantic_ownership_invalid", error);
+    }
+    if (!isBlueBubblesSemanticClaimRecord(value, expected)
+        || row.owner_json !== serializeBlueBubblesSemanticJson(value)) {
+        throw semanticStoreError("semantic_ownership_invalid");
+    }
+    return value;
+}
+function semanticOwnerIsStale(owner, deps) {
+    try {
+        if (owner.owner.bootIdentity !== semanticBootIdentity(deps))
+            return true;
+        if (!semanticIsProcessAlive(owner.owner.pid, deps))
+            return true;
+        const observedStart = semanticProcessStartedAt(owner.owner.pid, deps);
+        if (observedStart === null)
+            throw semanticStoreError("semantic_owner_liveness_failed");
+        return observedStart !== owner.owner.processStartedAt;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "semantic_owner_liveness_failed")
+            throw error;
+        throw semanticStoreError("semantic_owner_liveness_failed", error);
+    }
+}
+function inspectSemanticOwnerEvidence(ownerPath, input, deps) {
+    const storeFs = semanticFs(deps);
+    let stat;
+    try {
+        stat = storeFs.lstatSync(ownerPath);
+    }
+    catch (error) {
+        if (isNodeError(error, "ENOENT"))
+            return { status: "missing" };
+        throw error;
+    }
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+        return { status: "invalid", reason: semanticStoreError("semantic_owner_evidence_invalid") };
+    }
+    let bytes;
+    try {
+        bytes = storeFs.readFileSync(ownerPath, "utf8");
+    }
+    catch (error) {
+        return { status: "invalid", reason: error };
+    }
+    let value;
+    try {
+        value = JSON.parse(bytes);
+    }
+    catch (error) {
+        return { status: "invalid", reason: error };
+    }
+    if (!isBlueBubblesSemanticClaimRecord(value, input)
+        || bytes !== serializeBlueBubblesSemanticJson(value)) {
+        return { status: "invalid", reason: semanticStoreError("semantic_owner_evidence_invalid") };
+    }
+    return { status: "valid", record: value, bytes };
+}
+function reconcileSemanticOwnerEvidence(input, owner, deps) {
+    const ownerJson = serializeBlueBubblesSemanticJson(owner);
+    const evidence = inspectSemanticOwnerEvidence(input.ownerPath, input, deps);
+    if (evidence.status === "valid" && evidence.bytes === ownerJson) {
+        fsyncSemanticDirectory(input.directoryPath, semanticFs(deps));
+        return;
+    }
+    if (evidence.status !== "missing") {
+        quarantineSemanticRecord(input.ownerPath, input.recordKind, input.keyHash, deps, evidence.status === "invalid"
+            ? evidence.reason
+            : semanticStoreError("semantic_owner_evidence_mismatch"));
+    }
+    ensureSemanticOwnerEvidence(input, owner, ownerJson, deps);
+}
+function quarantineSemanticOwnerEvidenceIfPresent(input, deps) {
+    const evidence = inspectSemanticOwnerEvidence(input.ownerPath, input, deps);
+    if (evidence.status === "missing")
+        return;
+    quarantineSemanticRecord(input.ownerPath, input.recordKind, input.keyHash, deps, evidence.status === "invalid" ? evidence.reason : semanticStoreError("semantic_owner_stale"));
+}
+function ensureSemanticOwnerEvidence(input, owner, ownerJson, deps) {
+    const evidence = inspectSemanticOwnerEvidence(input.ownerPath, input, deps);
+    if (evidence.status === "valid" && evidence.bytes === ownerJson) {
+        fsyncSemanticDirectory(input.directoryPath, semanticFs(deps));
+        return;
+    }
+    if (evidence.status !== "missing") {
+        quarantineSemanticRecord(input.ownerPath, input.recordKind, input.keyHash, deps, evidence.status === "invalid"
+            ? evidence.reason
+            : semanticStoreError("semantic_owner_evidence_mismatch"));
+    }
+    const publication = publishImmutableSemanticRecord(input.directoryPath, input.ownerPath, owner, deps);
+    if (publication !== "published")
+        throw semanticStoreError("semantic_owner_evidence_collision");
+}
+function isSqliteBusy(error) {
+    if (!(error instanceof Error) || !("code" in error) || typeof error.code !== "string") {
+        return false;
+    }
+    return error.code.startsWith("SQLITE_BUSY") || error.code.startsWith("SQLITE_LOCKED");
+}
+function isSqliteError(error) {
+    return error instanceof Error
+        && "code" in error
+        && typeof error.code === "string"
+        && error.code.startsWith("SQLITE_");
+}
+function readSemanticRecord(finalPath, recordKind, keyHash, validate, deps) {
+    const initial = inspectSemanticRecord(finalPath, keyHash, validate, deps);
+    if (initial.status === "missing")
+        return null;
+    if (initial.status === "valid")
+        return initial.value;
+    const ownershipPath = path.join(path.dirname(path.dirname(finalPath)), "ownership.sqlite");
+    const startedAt = semanticNow(deps).getTime();
+    while (true) {
+        const result = withExclusiveSemanticOwnership(ownershipPath, deps, () => {
+            const current = inspectSemanticRecord(finalPath, keyHash, validate, deps);
+            if (current.status === "missing")
+                return null;
+            if (current.status === "valid")
+                return current.value;
+            quarantineSemanticRecord(finalPath, recordKind, keyHash, deps, current.reason);
+            return null;
+        });
+        if (result.status === "completed")
+            return result.value;
+        if (semanticNow(deps).getTime() - startedAt >= SEMANTIC_CLAIM_TIMEOUT_MS) {
+            throw semanticStoreError("semantic_ownership_busy");
+        }
+        semanticSleepSync(SEMANTIC_CLAIM_POLL_MS, deps);
+    }
+}
+function inspectSemanticRecord(finalPath, keyHash, validate, deps) {
+    const storeFs = semanticFs(deps);
+    if (!storeFs.existsSync(finalPath))
+        return { status: "missing" };
+    let bytes;
+    try {
+        bytes = storeFs.readFileSync(finalPath, "utf8");
+    }
+    catch (error) {
+        emitSemanticStoreError("unknown", keyHash, "semantic_record_read_failed", error);
+        throw semanticStoreError("semantic_record_read_failed", error);
+    }
+    let value;
+    try {
+        value = JSON.parse(bytes);
+    }
+    catch (error) {
+        return { status: "invalid", reason: error };
+    }
+    if (!validate(value)) {
+        return {
+            status: "invalid",
+            reason: semanticStoreError("semantic_record_invalid"),
+        };
+    }
+    return { status: "valid", value };
+}
+function quarantineSemanticRecord(finalPath, recordKind, keyHash, deps, reason) {
+    const storeFs = semanticFs(deps);
+    const paths = semanticQuarantinePaths(finalPath, recordKind, deps);
+    try {
+        storeFs.mkdirSync(paths.directoryPath, { recursive: true });
+        const sourceStat = storeFs.lstatSync(finalPath);
+        if (sourceStat.isSymbolicLink()) {
+            storeFs.symlinkSync(storeFs.readlinkSync(finalPath), paths.quarantinePath);
+        }
+        else {
+            storeFs.linkSync(finalPath, paths.quarantinePath);
+        }
+        fsyncSemanticDirectory(paths.directoryPath, storeFs);
+        storeFs.unlinkSync(finalPath);
+        fsyncSemanticDirectory(path.dirname(finalPath), storeFs);
+    }
+    catch (error) {
+        emitSemanticStoreError("unknown", keyHash, "semantic_quarantine_failed", error);
+        throw semanticStoreError("semantic_quarantine_failed", error);
+    }
+    emitSemanticStoreError("unknown", keyHash, "semantic_record_quarantined", reason);
+}
+function semanticQuarantinePaths(finalPath, recordKind, deps) {
+    const semanticRoot = path.dirname(path.dirname(finalPath));
+    const directoryPath = path.join(semanticRoot, "quarantine", recordKind);
+    const observedAtUnixMs = semanticNow(deps).getTime();
+    const uuid = semanticRandomUuid(deps);
+    return {
+        directoryPath,
+        quarantinePath: path.join(directoryPath, `${path.basename(finalPath)}.${observedAtUnixMs}.${uuid}.json`),
+    };
+}
+function hasSemanticQuarantine(quarantineRoot, recordKind, originalBase, deps) {
+    const storeFs = semanticFs(deps);
+    const directoryPath = path.join(quarantineRoot, recordKind);
+    if (!storeFs.existsSync(directoryPath))
+        return false;
+    return storeFs.readdirSync(directoryPath).some((name) => name.startsWith(`${originalBase}.`));
+}
+function isBlueBubblesSemanticCapture(value, expectedKeyHash) {
+    if (!isRecord(value) || !hasExactKeys(value, CAPTURE_KEYS))
+        return false;
+    if (value.schemaVersion !== 1
+        || typeof value.canonicalKey !== "string"
+        || value.keyHash !== expectedKeyHash
+        || sha256Utf8(value.canonicalKey) !== value.keyHash
+        || normalizeProviderNamespace(value.providerNamespace) !== value.providerNamespace
+        || exactIsoMilliseconds(value.capturedAt) === null
+        || !isRecord(value.event)
+        || !hasExactKeys(value.event, CAPTURE_EVENT_KEYS))
+        return false;
+    const event = value.event;
+    if (event.provider !== "bluebubbles"
+        || typeof event.kind !== "string"
+        || !SEMANTIC_EVENT_KINDS.has(event.kind)
+        || !isNullableString(event.eventGuid)
+        || typeof event.fromMe !== "boolean"
+        || !isObservedIngressIdentity(event.actor)
+        || !Array.isArray(event.participants)
+        || !event.participants.every(isObservedIngressIdentity)
+        || !participantsAreSorted(event.participants)
+        || typeof event.sourceEventType !== "string"
+        || !isNullableString(event.sessionKey)
+        || !isNullableString(event.chatGuid)
+        || !isNullableString(event.chatIdentifier)
+        || !isNullableString(event.text)
+        || !isNullableString(event.textSha256)
+        || !isNullableString(event.targetGuid)
+        || !isIngressTargetAuthorship(event.targetAuthorship)
+        || !isIngressCanonicalAction(event.canonicalAction)
+        || !isIngressCanonicalValue(event.canonicalValue)
+        || !isNullableString(event.rawTransportValue)
+        || !(event.effectiveAt === null || exactIsoMilliseconds(event.effectiveAt) !== null)
+        || !isNullableString(event.revision)
+        || !isNullableString(event.contentSha256))
+        return false;
+    if (event.text === null) {
+        if (event.textSha256 !== null)
+            return false;
+    }
+    else if (event.textSha256 !== sha256Utf8(event.text)) {
+        return false;
+    }
+    return captureIdentityMatchesEvent(value);
+}
+function isBlueBubblesSemanticObservationOrderRecord(value, expectedKeyHash, expectedCaptureHash) {
+    return isRecord(value)
+        && hasExactKeys(value, OBSERVATION_ORDER_KEYS)
+        && value.schemaVersion === 1
+        && value.keyHash === expectedKeyHash
+        && value.captureHash === expectedCaptureHash
+        && exactIsoMilliseconds(value.observedAt) !== null
+        && isBlueBubblesObservationEpoch(value.observationEpoch)
+        && typeof value.observationOrdinal === "number"
+        && Number.isSafeInteger(value.observationOrdinal)
+        && value.observationOrdinal > 0;
+}
+function isBlueBubblesObservationEpoch(value) {
+    if (typeof value !== "string")
+        return false;
+    const parts = value.split("/");
+    return parts.length === 2
+        && exactIsoMilliseconds(parts[0]) !== null
+        && UUID_V4_PATTERN.test(parts[1]);
+}
+function captureIdentityMatchesEvent(value) {
+    const event = value.event;
+    const coordinateGeneration = event.kind === "reaction"
+        && event.revision === null
+        && event.effectiveAt === null
+        ? reactionGenerationFromCanonicalKey(value.canonicalKey)
+        : undefined;
+    if (coordinateGeneration === null)
+        return false;
+    const identity = buildBlueBubblesSemanticIdentity({
+        providerNamespace: value.providerNamespace,
+        kind: event.kind,
+        eventGuid: event.eventGuid,
+        targetGuid: event.targetGuid,
+        actorExternalId: event.actor.externalId,
+        canonicalValue: event.canonicalValue ?? undefined,
+        canonicalAction: event.canonicalAction ?? undefined,
+        revision: event.revision ?? undefined,
+        effectiveTimestamp: event.effectiveAt === null ? undefined : Date.parse(event.effectiveAt),
+        text: event.text ?? undefined,
+        coordinateGeneration,
+    });
+    return identity !== null
+        && identity.canonicalKey === value.canonicalKey
+        && identity.keyHash === value.keyHash;
+}
+function reactionGenerationFromCanonicalKey(canonicalKey) {
+    let tuple;
+    try {
+        tuple = JSON.parse(canonicalKey);
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(tuple) || tuple.length !== 9 || typeof tuple[8] !== "string")
+        return null;
+    const match = /^generation:(0|[1-9]\d*)$/.exec(tuple[8]);
+    if (!match)
+        return null;
+    const generation = Number(match[1]);
+    return Number.isInteger(generation) && generation >= 0 ? generation : null;
+}
+function isBlueBubblesSemanticHandledRecord(value, expectedKeyHash) {
+    return isRecord(value)
+        && hasExactKeys(value, HANDLED_KEYS)
+        && value.schemaVersion === 1
+        && typeof value.canonicalKey === "string"
+        && value.keyHash === expectedKeyHash
+        && sha256Utf8(value.canonicalKey) === value.keyHash
+        && exactIsoMilliseconds(value.handledAt) !== null
+        && typeof value.outcome === "string"
+        && SEMANTIC_HANDLED_OUTCOMES.has(value.outcome)
+        && (value.detailCode === null || typeof value.detailCode === "string");
+}
+function isBlueBubblesSemanticClaimRecord(value, expected) {
+    if (!isRecord(value) || !hasExactKeys(value, CLAIM_KEYS) || !isRecord(value.owner))
+        return false;
+    return hasExactKeys(value.owner, CLAIM_OWNER_KEYS)
+        && value.schemaVersion === 1
+        && value.canonicalKey === expected.canonicalKey
+        && value.keyHash === expected.keyHash
+        && sha256Utf8(value.canonicalKey) === value.keyHash
+        && value.owner.operationId === expected.operationId
+        && typeof value.owner.pid === "number"
+        && Number.isInteger(value.owner.pid)
+        && value.owner.pid > 0
+        && typeof value.owner.bootIdentity === "string"
+        && value.owner.bootIdentity.length > 0
+        && typeof value.owner.processStartedAt === "string"
+        && value.owner.processStartedAt.length > 0
+        && exactIsoMilliseconds(value.owner.acquiredAt) !== null;
+}
+function isBlueBubblesReactionCoordinateRecord(value, coordinateKey, coordinateHash) {
+    return isRecord(value)
+        && hasExactKeys(value, COORDINATE_KEYS)
+        && value.schemaVersion === 1
+        && value.coordinateKey === coordinateKey
+        && value.coordinateHash === coordinateHash
+        && sha256Utf8(coordinateKey) === coordinateHash
+        && typeof value.generation === "number"
+        && Number.isInteger(value.generation)
+        && value.generation >= 0
+        && (value.lastAction === "add" || value.lastAction === "remove")
+        && exactIsoMilliseconds(value.updatedAt) !== null;
+}
+function isObservedIngressIdentity(value) {
+    return isRecord(value)
+        && hasExactKeys(value, OBSERVED_IDENTITY_KEYS)
+        && value.provider === "imessage-handle"
+        && typeof value.externalId === "string"
+        && value.externalId.length > 0
+        && normalizeIngressIdentifier(value.externalId) === value.externalId
+        && (value.displayName === null || typeof value.displayName === "string");
+}
+function participantsAreSorted(participants) {
+    return participants.every((participant, index) => (index === 0 || participants[index - 1].externalId.localeCompare(participant.externalId) <= 0));
+}
+function isIngressTargetAuthorship(value) {
+    return value === null || value === "agent" || value === "non_agent_unknown";
+}
+function isIngressCanonicalAction(value) {
+    return value === null || value === "add" || value === "remove";
+}
+function isIngressCanonicalValue(value) {
+    return value === null || (typeof value === "string"
+        && CANONICAL_VALUES.has(value));
+}
+function isNullableString(value) {
+    return value === null || typeof value === "string";
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value);
+    return actual.length === keys.length && actual.every((key, index) => key === keys[index]);
+}
+function semanticRecordPath(directoryPath, keyHash) {
+    return path.join(directoryPath, `${validatedKeyHash(keyHash)}.json`);
+}
+function validatedKeyHash(value) {
+    if (!SEMANTIC_KEY_HASH_PATTERN.test(value))
+        throw semanticStoreError("semantic_key_hash_invalid");
+    return value;
+}
+function semanticTempPath(finalPath, deps) {
+    return path.join(path.dirname(finalPath), `.${path.basename(finalPath)}.${semanticPid(deps)}.${semanticRandomUuid(deps)}.tmp`);
+}
+function semanticFs(deps) {
+    return deps.fs ?? fs;
+}
+function semanticNow(deps) {
+    return (deps.now ?? (() => new Date()))();
+}
+function semanticRandomUuid(deps) {
+    const uuid = (deps.randomUUID ?? node_crypto_1.randomUUID)();
+    if (!UUID_V4_PATTERN.test(uuid))
+        throw semanticStoreError("semantic_uuid_invalid");
+    return uuid;
+}
+function semanticPid(deps) {
+    const pid = (deps.pid ?? (() => process.pid))();
+    if (!Number.isInteger(pid) || pid <= 0)
+        throw semanticStoreError("semantic_pid_invalid");
+    return pid;
+}
+function semanticBootIdentity(deps) {
+    const identity = deps.bootIdentity ? deps.bootIdentity() : defaultBootIdentity(deps);
+    return requiredProbeIdentity(identity);
+}
+function semanticProcessStartedAt(pid, deps) {
+    return deps.processStartedAt
+        ? deps.processStartedAt(pid)
+        : defaultProcessStartedAt(pid, deps);
+}
+function semanticIsProcessAlive(pid, deps) {
+    return deps.isProcessAlive ? deps.isProcessAlive(pid) : defaultIsProcessAlive(pid, deps);
+}
+async function semanticSleep(milliseconds, deps) {
+    if (deps.sleep) {
+        await deps.sleep(milliseconds);
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function semanticSleepSync(milliseconds, deps) {
+    if (deps.sleepSync) {
+        deps.sleepSync(milliseconds);
+        return;
+    }
+    const waitCell = new Int32Array(new SharedArrayBuffer(4));
+    Atomics.wait(waitCell, 0, 0, milliseconds);
+}
+function requiredProbeIdentity(value) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw semanticStoreError("semantic_owner_liveness_failed");
+    }
+    return value;
+}
+function defaultBootIdentity(deps) {
+    const platform = deps.platform ?? process.platform;
+    const storeFs = semanticFs(deps);
+    const run = deps.execFileSync ?? node_child_process_1.execFileSync;
+    if (platform === "linux") {
+        const bootId = storeFs.readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+        return requiredProbeIdentity(`linux:${bootId}`);
+    }
+    if (platform === "darwin" || platform === "freebsd") {
+        const output = run("/usr/sbin/sysctl", ["-n", "kern.boottime"], {
+            encoding: "utf8",
+        }).trim();
+        return requiredProbeIdentity(`${platform}:${output}`);
+    }
+    if (platform === "win32") {
+        const output = run("powershell.exe", [
+            "-NoProfile",
+            "-Command",
+            "(Get-CimInstance Win32_OperatingSystem).LastBootUpTime.ToUniversalTime().Ticks",
+        ], { encoding: "utf8" }).trim();
+        return requiredProbeIdentity(`win32:${output}`);
+    }
+    const uptime = deps.uptime ?? os.uptime;
+    const bootEpochSeconds = Math.round((semanticNow(deps).getTime() - (uptime() * 1_000)) / 1_000);
+    return requiredProbeIdentity(`${platform}:${bootEpochSeconds}`);
+}
+function defaultProcessStartedAt(pid, deps) {
+    const platform = deps.platform ?? process.platform;
+    const storeFs = semanticFs(deps);
+    const run = deps.execFileSync ?? node_child_process_1.execFileSync;
+    if (platform === "linux") {
+        try {
+            const stat = storeFs.readFileSync(`/proc/${pid}/stat`, "utf8");
+            const closeParen = stat.lastIndexOf(")");
+            if (closeParen < 0)
+                return null;
+            const fields = stat.slice(closeParen + 2).trim().split(/\s+/);
+            return fields[19] ? `linux:${fields[19]}` : null;
+        }
+        catch (error) {
+            if (isNodeError(error, "ENOENT") || isNodeError(error, "ESRCH"))
+                return null;
+            throw error;
+        }
+    }
+    if (platform === "win32") {
+        try {
+            const output = run("powershell.exe", ["-NoProfile", "-Command", `(Get-Process -Id ${pid}).StartTime.ToUniversalTime().Ticks`], { encoding: "utf8" }).trim();
+            return output ? `win32:${output}` : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        const output = run("/bin/ps", ["-o", "lstart=", "-p", String(pid)], {
+            encoding: "utf8",
+        }).trim();
+        return output ? `${platform}:${output}` : null;
+    }
+    catch {
+        return null;
+    }
+}
+function defaultIsProcessAlive(pid, deps) {
+    const kill = deps.kill ?? process.kill;
+    try {
+        kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (isNodeError(error, "ESRCH"))
+            return false;
+        if (isNodeError(error, "EPERM"))
+            return true;
+        throw error;
+    }
+}
+function nextOwnerAcquiredAt(ownerPath, deps) {
+    const observed = semanticNow(deps).getTime();
+    const previous = lastOwnerAcquisitionMs.get(ownerPath);
+    const next = previous === undefined ? observed : Math.max(observed, previous + 1);
+    lastOwnerAcquisitionMs.set(ownerPath, next);
+    return new Date(next).toISOString();
+}
+function fsyncSemanticDirectory(directoryPath, storeFs) {
+    const directoryFd = storeFs.openSync(directoryPath, "r");
+    try {
+        storeFs.fsyncSync(directoryFd);
+    }
+    finally {
+        storeFs.closeSync(directoryFd);
+    }
+}
+function semanticStoreError(code, cause) {
+    return cause === undefined ? new Error(code) : new Error(code, { cause });
+}
+function emitCaptureError(agentName, keyHash, error) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "senses",
+        event: "bluebubbles_semantic_capture_error",
+        message: "failed to publish bluebubbles semantic capture",
+        meta: { agentName, keyHash, reason: errorReason(error) },
+    });
+}
+function emitSemanticStoreError(agentName, keyHash, code, error) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "senses",
+        event: "bluebubbles_semantic_store_error",
+        message: "bluebubbles semantic store operation failed",
+        meta: { agentName, keyHash, code, reason: errorReason(error) },
+    });
+}
+function errorReason(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function createCutover(deps) {
+    const providerNamespace = normalizeProviderNamespace((deps.randomUUID ?? node_crypto_1.randomUUID)());
+    if (!providerNamespace)
+        throw new Error("semantic_provider_namespace_invalid");
+    const effectiveAt = (deps.now ?? (() => new Date()))().toISOString();
+    if (!exactIsoMilliseconds(effectiveAt))
+        throw new Error("semantic_cutover_timestamp_invalid");
+    return { schemaVersion: 1, providerNamespace, effectiveAt };
+}
+function isBlueBubblesSemanticCutover(value) {
+    if (!isRecord(value))
+        return false;
+    if (JSON.stringify(Object.keys(value)) !== JSON.stringify(CUTOVER_KEYS))
+        return false;
+    return value.schemaVersion === 1
+        && normalizeProviderNamespace(value.providerNamespace) === value.providerNamespace
+        && exactIsoMilliseconds(value.effectiveAt) !== null;
+}
+function identityFromKey(tuple, handleable, discriminator = null, coordinateKey = null, coordinateHash = null) {
+    const canonicalKey = JSON.stringify(tuple);
+    return {
+        canonicalKey,
+        keyHash: sha256Utf8(canonicalKey),
+        handleable,
+        discriminator,
+        coordinateKey,
+        coordinateHash,
+    };
+}
+function mutationDiscriminator(input) {
+    const revision = normalizedRevision(input.revision);
+    if (revision)
+        return `revision:${revision}`;
+    return effectiveTimestampDiscriminator(input.effectiveTimestamp);
+}
+function effectiveTimestampDiscriminator(value) {
+    const effectiveAt = finiteTimestampIso(value);
+    return effectiveAt ? `effectiveAt:${effectiveAt}` : null;
+}
+function generationDiscriminator(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0
+        ? `generation:${value}`
+        : null;
+}
+function finiteTimestampIso(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return null;
+    const date = new Date(value);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+}
+function normalizedRevision(value) {
+    if (typeof value !== "string")
+        return null;
+    return value.trim() || null;
+}
+function requiredIdentifier(value) {
+    if (value === null || value === undefined)
+        return null;
+    const normalized = normalizeIngressIdentifier(value);
+    return normalized || null;
+}
+function normalizeProviderNamespace(value) {
+    const normalized = requiredIdentifier(value);
+    return normalized && UUID_V4_PATTERN.test(normalized) ? normalized : null;
+}
+function normalizeCanonicalValue(value) {
+    return typeof value === "string"
+        && CANONICAL_VALUES.has(value)
+        ? value
+        : null;
+}
+function normalizeCanonicalAction(value) {
+    return typeof value === "string"
+        && CANONICAL_ACTIONS.has(value)
+        ? value
+        : null;
+}
+function normalizeDisplayName(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function nullableString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function exactIsoMilliseconds(value) {
+    if (typeof value !== "string" || !ISO_MILLISECONDS_PATTERN.test(value))
+        return null;
+    const milliseconds = Date.parse(value);
+    return Number.isFinite(milliseconds) && new Date(milliseconds).toISOString() === value ? value : null;
+}
+function sha256Utf8(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input, "utf8").digest("hex");
+}
+function fsyncDirectory(directoryPath) {
+    const directoryFd = fs.openSync(directoryPath, "r");
+    try {
+        fs.fsyncSync(directoryFd);
+    }
+    finally {
+        fs.closeSync(directoryFd);
+    }
+}
+function isNodeError(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function emitLegacyRecoveryBlocked(value) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.bluebubbles_legacy_recovery_blocked",
+        message: "blocked legacy or actorless bluebubbles recovery record",
+        meta: {
+            schemaVersion: 0,
+            actorPresent: false,
+            recordKind: recoveryRecordKind(value),
+            reason: "legacy_or_actorless",
+        },
+    });
+}
+function emitInvalidSemanticRecoveryRecord(value, actorPresent, reason) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.bluebubbles_semantic_recovery_invalid",
+        message: "blocked invalid v1 bluebubbles recovery record",
+        meta: {
+            schemaVersion: 1,
+            actorPresent,
+            recordKind: recoveryRecordKind(value),
+            reason,
+        },
+    });
+}
+function recoveryRecordKind(value) {
+    const record = isRecord(value) ? value : null;
+    return typeof record?.mutationType === "string"
+        ? record.mutationType
+        : isRecord(record?.event) && typeof record.event.kind === "string"
+            ? record.event.kind
+            : "inbound";
+}