interlaced 2.8.4__tar.gz → 2.8.6__tar.gz

{interlaced-2.8.4/src/interlaced.egg-info → interlaced-2.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlaced
-Version: 2.8.4
+Version: 2.8.6
 Summary: Python and SQL models in one DAG. Transformation, orchestration and durable streaming in one process, on DuckDB and Postgres.
 Author-email: Mark <mark@interlace.sh>
 License-Expression: MIT

{interlaced-2.8.4 → interlaced-2.8.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "interlaced"
-version = "2.8.4"
+version = "2.8.6"
 description = "Python and SQL models in one DAG. Transformation, orchestration and durable streaming in one process, on DuckDB and Postgres."
 readme = "README.md"
 requires-python = ">=3.12"

{interlaced-2.8.4 → interlaced-2.8.6}/src/interlace/config/config.py

@@ -250,6 +250,9 @@ class ProjectConfig(BaseModel):
     default_engine: str = "default"
     engines: dict[str, EngineConfig] = Field(default_factory=dict)
     state_path: str = ".interlace/state.db"  # SQLite control-plane database
+    # When set, snapshots, the queue, and the event log live in this Postgres
+    # database (schema ``interlace``) instead of ``state_path``. Not the warehouse.
+    state_url: str | None = None
     # Optional NDJSON mirror of the operator event log. Unset writes nowhere.
     # One JSON line is appended after each SQLite commit (CLI and daemon share it).
     event_log_path: str | None = None
@@ -275,6 +278,11 @@ class ProjectConfig(BaseModel):
     secrets: dict[str, SecretConfig] = Field(default_factory=dict)
     quack_token: str | None = None  # token for quack: databases (or INTERLACE_QUACK_TOKEN)
     stream_path: str = ".interlace/streams.db"  # durable stream log (SQLite WAL)
+    # When set, the stream log lives in this Postgres database (schema
+    # ``interlace_streams``) instead of ``stream_path``. A commit is durable
+    # under Postgres ``synchronous_commit`` (the default), the same promise as
+    # the SQLite WAL fsync.
+    stream_url: str | None = None
     # Databases to ATTACH to the warehouse engine at open: alias -> DuckDB attach
     # URI/path (a .duckdb file, "postgres:...", "sqlite:...", ...). Models can read
     # them and table exports can write to them as <alias>.<schema>.<table>.

{interlaced-2.8.4 → interlaced-2.8.6}/src/interlace/dsl/decorators.py

@@ -32,7 +32,8 @@ ModelFn = Callable[..., Any]
 
 
 def normalize_schedule(schedule: Mapping[str, Any] | None, *, model: str) -> dict[str, str] | None:
-    """Schedules are string values. ``fresh: {column, within}`` becomes ``"column within"``."""
+    """Schedules are string values. ``fresh: {column, within}`` becomes ``"column within"``.
+    ``after: [a, b]`` becomes ``"a,b"``."""
     if not schedule:
         return None
     normalised: dict[str, str] = {}
@@ -46,6 +47,14 @@ def normalize_schedule(schedule: Mapping[str, Any] | None, *, model: str) -> dic
                 raise DefinitionError(f"model {model!r}: fresh.within must be a window like '2h'")
             normalised[key] = f"{column.strip()} {window.strip()}"
             continue
+        if key == "after" and isinstance(value, (list, tuple)):
+            names = [str(item).strip() for item in value]
+            if not names or any(not name for name in names):
+                raise DefinitionError(f"model {model!r}: after must name a model, or a list of models")
+            normalised[key] = ",".join(names)
+            continue
+        if key == "after" and not isinstance(value, str):
+            raise DefinitionError(f"model {model!r}: after must name a model, or a list of models")
         if not isinstance(value, str):
             raise DefinitionError(f"model {model!r}: schedule {key!r} must be a string")
         normalised[key] = value

{interlaced-2.8.4 → interlaced-2.8.6}/src/interlace/plan/differ.py

@@ -338,6 +338,8 @@ async def diff(  # noqa: C901
     plan = Plan(environment=environment)
     impact: dict[str, str] = {}  # changed models only: "semantic" | "additive" | "clean"
     touched: dict[str, frozenset[str] | None] = {}  # semantic models: provably-changed columns (None = all)
+    # downstream models: the upstream columns that forced the rebuild
+    indirect: dict[str, frozenset[str]] = {}
 
     previous_snapshots = await state.get_snapshots(
         (name, fingerprint)
@@ -410,6 +412,8 @@ async def diff(  # noqa: C901
                     consumed = _consumed_columns(model.ast, dep)
                     if dep_touched is not None and consumed is not None and not (consumed & dep_touched):
                         continue  # column-pruned: reads only provably-unchanged columns
+                    if dep_touched is not None and consumed is not None:
+                        indirect[model.name] = consumed & dep_touched
                     verdict = "semantic"
                     break
                 if dep_impact == "additive" and _selects_star(model.ast):
@@ -436,8 +440,15 @@ async def diff(  # noqa: C901
         )
         if inherit:
             category = ChangeCategory.FORWARD_ONLY
+        shown = added
+        if impact.get(model.name) == "semantic":
+            own = touched.get(model.name)
+            if own:
+                shown = tuple(sorted(own))
+            elif model.name in indirect:
+                shown = tuple(sorted(indirect[model.name]))
         plan.changes.append(
-            ModelChange(model.name, ChangeType.MODIFIED, category, previous_fingerprint, model.fingerprint, added)
+            ModelChange(model.name, ChangeType.MODIFIED, category, previous_fingerprint, model.fingerprint, shown)
         )
         if inherit:  # copy-on-write: history seeds the NEW table; checks gate before views move
             snapshot = replace(

{interlaced-2.8.4 → interlaced-2.8.6}/src/interlace/plan/schedule.py

@@ -25,7 +25,8 @@ from interlace.ir.relation import TableRef
 from interlace.plan.backfill import run_backfill
 from interlace.plan.plan import BackfillTask, Plan
 from interlace.plan.result import ApplyResult, ProgressCallback, build_detail, failure_detail
-from interlace.state.store import StateStore
+from interlace.scheduler.completion import after_waiters, wake_after
+from interlace.state.store import SqliteStateStore, StateStore
 
 logger = logging.getLogger("interlace.apply")
 
@@ -123,6 +124,7 @@ async def schedule_builds(  # noqa: C901
                 deps.add(ref)
         blocking[name] = deps
 
+    waiting = after_waiters(compiled)
     finished = {name: asyncio.Event() for name in per_model}
     build_slots = asyncio.Semaphore(max(1, parallelism))
 
@@ -163,6 +165,8 @@ async def schedule_builds(  # noqa: C901
         finished[name].set()
         if on_progress is not None:
             on_progress(name, "done", build_detail(result, name))
+        if isinstance(state, SqliteStateStore):
+            await wake_after(state, compiled, name, building=set(per_model), waiters=waiting)
 
     # Copied into each build task at creation, so a Python model that registers
     # models (including from a worker thread) appends to this same list.

{interlaced-2.8.4 → interlaced-2.8.6}/src/interlace/project.py

@@ -375,15 +375,20 @@ class Project:
         )
 
     async def open_state(self) -> SqliteStateStore:
-        path = self.root / self.config.state_path
-        path.parent.mkdir(parents=True, exist_ok=True)
-        store = await SqliteStateStore.open(path)
+        if self.config.state_url:
+            store = await SqliteStateStore.open_postgres(self.config.state_url)
+        else:
+            path = self.root / self.config.state_path
+            path.parent.mkdir(parents=True, exist_ok=True)
+            store = await SqliteStateStore.open(path)
         if self.config.event_log_path:
             target = Path(self.config.event_log_path)
             store.event_log_path = str(target if target.is_absolute() else self.root / target)
         return store
 
     async def open_stream_log(self) -> SqliteStreamLog:
+        if self.config.stream_url:
+            return await SqliteStreamLog.open_postgres(self.config.stream_url)
         path = self.root / self.config.stream_path
         path.parent.mkdir(parents=True, exist_ok=True)
         return await SqliteStreamLog.open(path)

interlaced-2.8.6/src/interlace/scheduler/__init__.py

@@ -0,0 +1,39 @@
+"""Orchestration: triggers, the trigger engine, and the worker (queue = state store).
+
+Submodules import each other. This package does not load them up front: importing
+``interlace.scheduler.completion`` must not pull in the worker, which imports the
+apply path that imports completion.
+"""
+
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+__all__ = [
+    "CronTrigger",
+    "IntervalTrigger",
+    "RunRequest",
+    "Trigger",
+    "TriggerEngine",
+    "build_triggers",
+    "drain",
+]
+
+_EXPORTS: dict[str, tuple[str, str]] = {
+    "CronTrigger": ("interlace.scheduler.triggers", "CronTrigger"),
+    "IntervalTrigger": ("interlace.scheduler.triggers", "IntervalTrigger"),
+    "RunRequest": ("interlace.scheduler.triggers", "RunRequest"),
+    "Trigger": ("interlace.scheduler.triggers", "Trigger"),
+    "TriggerEngine": ("interlace.scheduler.engine", "TriggerEngine"),
+    "build_triggers": ("interlace.scheduler.engine", "build_triggers"),
+    "drain": ("interlace.scheduler.worker", "drain"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    found = _EXPORTS.get(name)
+    if found is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    module_name, attr = found
+    return getattr(importlib.import_module(module_name), attr)

interlaced-2.8.6/src/interlace/scheduler/completion.py

@@ -0,0 +1,132 @@
+"""Run a model when another model finishes.
+
+``schedule: {after: …}`` is not a clock tick. Apply calls :func:`wake_after` once
+a build reaches ``model.done``. The trigger engine only validates the graph.
+"""
+
+from __future__ import annotations
+
+import time
+
+from interlace.exceptions import DefinitionError
+from interlace.graph.project import CompiledProject
+from interlace.state.store import SqliteStateStore
+
+_SCHEDULE_KINDS = ("cron", "every", "watch", "on_change", "fresh", "after", "webhook")
+
+
+def schedule_kind(model: str, schedule: dict[str, str]) -> tuple[str, str]:
+    """The one schedule key and its value.
+
+    Cron, interval, file watch, table change, freshness, upstream completion, or webhook.
+    """
+    present = [key for key in _SCHEDULE_KINDS if key in schedule]
+    if len(present) != 1:
+        raise DefinitionError(
+            f"model {model!r}: schedule needs exactly one of {', '.join(_SCHEDULE_KINDS)}",
+            details={"schedule": schedule},
+        )
+    return present[0], schedule[present[0]]
+
+
+def scheduled_closure(project: CompiledProject, models: list[str]) -> list[str]:
+    """The triggered models plus every model downstream of them.
+
+    A cron, interval, file watch, table change, freshness, upstream completion, or webhook
+    means that model's inputs changed. Downstream snapshots would otherwise keep the
+    previous build. An explicit ``run --select`` is not expanded here: ``model``,
+    ``model+``, and ``+model`` stay exactly what was asked for.
+    """
+    chosen: set[str] = set()
+    for name in models:
+        chosen.add(name)
+        if name in project.models:
+            chosen |= project.graph.descendants(name)
+    return sorted(chosen)
+
+
+def after_waiters(project: CompiledProject) -> dict[str, list[str]]:
+    """Map an upstream model to the models that run when it finishes.
+
+    ``schedule: {after: raw}`` or ``{after: [raw, staging]}`` (stored as
+    ``"raw,staging"``). A model cannot name itself, and the ``after`` edges
+    cannot cycle — otherwise two models would enqueue each other forever.
+    """
+    found: dict[str, list[str]] = {}
+    for model in project.models.values():
+        if not model.schedule or "after" not in model.schedule:
+            continue
+        kind, value = schedule_kind(model.name, model.schedule)
+        if kind != "after":
+            continue
+        names = list(dict.fromkeys(part.strip() for part in value.split(",") if part.strip()))
+        if not names:
+            raise DefinitionError(f"model {model.name!r}: after must name a model")
+        if model.name in names:
+            raise DefinitionError(f"model {model.name!r}: after cannot name itself")
+        missing = [name for name in names if name not in project.models]
+        if missing:
+            raise DefinitionError(
+                f"model {model.name!r}: after names unknown models: {', '.join(missing)}",
+                details={"missing": missing},
+            )
+        for name in names:
+            found.setdefault(name, []).append(model.name)
+    _reject_after_cycles(found)
+    return found
+
+
+def _reject_after_cycles(waiters: dict[str, list[str]]) -> None:
+    visiting: set[str] = set()
+    visited: set[str] = set()
+
+    def walk(node: str) -> None:
+        if node in visited:
+            return
+        if node in visiting:
+            raise DefinitionError(f"schedule after has a cycle through {node!r}")
+        visiting.add(node)
+        for nxt in waiters.get(node, ()):
+            walk(nxt)
+        visiting.remove(node)
+        visited.add(node)
+
+    for node in list(waiters):
+        walk(node)
+
+
+async def wake_after(
+    store: SqliteStateStore,
+    project: CompiledProject,
+    upstream: str,
+    *,
+    building: set[str],
+    waiters: dict[str, list[str]] | None = None,
+    stamp: str | None = None,
+) -> int:
+    """Enqueue models waiting on ``upstream`` after it reaches ``model.done``.
+
+    ``building`` is the set already in this apply, so a model the plan is
+    constructing is not queued again. One stamp shared by the waiters of a
+    single finish: a retry of the same finish dedupes, a later finish does not.
+    Returns how many runs were newly enqueued.
+    """
+    table = after_waiters(project) if waiters is None else waiters
+    pending = [name for name in table.get(upstream, ()) if name not in building]
+    if not pending:
+        return 0
+    order = {model.name: index for index, model in enumerate(project.ordered())}
+    pending.sort(key=lambda name: order.get(name, 0))
+    token = stamp if stamp is not None else str(time.time_ns())
+    covered: set[str] = set(building)
+    enqueued = 0
+    for name in pending:
+        if name in covered:
+            continue
+        selector = scheduled_closure(project, [name])
+        key = f"after:{name}:{upstream}:{token}"
+        if await store.enqueue_run(key, selector, None, 0):
+            enqueued += 1
+            await store.append_event("run.enqueued", entity=key, payload={"models": selector, "after": upstream})
+        covered.update(selector)
+    return enqueued

{interlaced-2.8.4 → interlaced-2.8.6}/src/interlace/scheduler/engine.py

@@ -22,6 +22,7 @@ from interlace.graph.project import CompiledModel, CompiledProject
 from interlace.ir.canonicalize import table_references
 from interlace.ir.layout import env_view
 from interlace.ir.relation import TableRef
+from interlace.scheduler.completion import after_waiters, schedule_kind, scheduled_closure
 from interlace.scheduler.triggers import (
     ABSENT,
     CronTrigger,
@@ -34,21 +35,9 @@ from interlace.scheduler.triggers import (
 from interlace.state.interval import Grain, as_grain, parse_grain
 from interlace.state.store import SqliteStateStore
 
-_SCHEDULE_KINDS = ("cron", "every", "watch", "on_change", "fresh", "webhook")
 _IDENT = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
 
 
-def schedule_kind(model: str, schedule: dict[str, str]) -> tuple[str, str]:
-    """The one schedule key and its value. Cron, interval, file watch, table change, freshness, or webhook."""
-    present = [key for key in _SCHEDULE_KINDS if key in schedule]
-    if len(present) != 1:
-        raise DefinitionError(
-            f"model {model!r}: schedule needs exactly one of {', '.join(_SCHEDULE_KINDS)}",
-            details={"schedule": schedule},
-        )
-    return present[0], schedule[present[0]]
-
-
 def webhook_targets(project: CompiledProject) -> dict[str, str]:
     """Map a webhook name to the model ``POST /hooks/{name}`` enqueues."""
     found: dict[str, str] = {}
@@ -71,7 +60,8 @@ def build_triggers(project: CompiledProject, *, root: Path | None = None, enviro
     ``root`` is the project directory a ``watch:`` glob is relative to.
     ``environment`` names the view an ``on_change`` or ``fresh`` schedule reads when its
     source is another model. Webhook schedules are validated here and enqueued
-    by ``POST /hooks/{name}``, so they do not become ticking triggers.
+    by ``POST /hooks/{name}``. ``after`` is validated here and enqueued when the
+    upstream model finishes. Neither becomes a ticking trigger.
     """
     triggers: list[Trigger] = []
     for model in project.models.values():
@@ -79,6 +69,7 @@ def build_triggers(project: CompiledProject, *, root: Path | None = None, enviro
         if trigger is not None:
             triggers.append(trigger)
     webhook_targets(project)  # reject two models sharing one hook name
+    after_waiters(project)  # reject unknown names and cycles
     return triggers
 
 
@@ -175,22 +166,6 @@ def _infer_change_table(
     )
 
 
-def scheduled_closure(project: CompiledProject, models: list[str]) -> list[str]:
-    """The triggered models plus every model downstream of them.
-
-    A cron, interval, file watch, table change, freshness, or webhook means that model's inputs changed.
-    Downstream snapshots would otherwise keep the previous build. An explicit
-    ``run --select`` is not expanded here: ``model``, ``model+``, and ``+model``
-    stay exactly what was asked for.
-    """
-    chosen: set[str] = set()
-    for name in models:
-        chosen.add(name)
-        if name in project.models:
-            chosen |= project.graph.descendants(name)
-    return sorted(chosen)
-
-
 class TriggerEngine:
     """Evaluates triggers on each tick and enqueues due runs."""
 

{interlaced-2.8.4 → interlaced-2.8.6}/src/interlace/service/routes/catalog.py

@@ -142,6 +142,7 @@ async def get_schedules(state: State) -> list[ScheduleInfo]:
             "watch": f"watch:{name}",
             "on_change": f"change:{name}",
             "fresh": f"fresh:{name}",
+            "after": f"after:{name}",
         }.get(kind)
         last = await state.store.get_trigger_last_fired(trigger_id) if trigger_id else None
 

{interlaced-2.8.4 → interlaced-2.8.6}/src/interlace/service/types.py

@@ -297,7 +297,7 @@ class ConnectionInfo(msgspec.Struct):
 
 class ScheduleInfo(msgspec.Struct):
     model: str
-    kind: str  # "cron" | "every" | "watch" | "on_change" | "fresh" | "webhook"
+    kind: str  # "cron" | "every" | "watch" | "on_change" | "fresh" | "after" | "webhook"
     expression: str
     next_fire: str | None
     last_fired: str | None

{interlaced-2.8.4 → interlaced-2.8.6}/src/interlace/service/ui/js/views/plan.js

@@ -143,7 +143,10 @@ export async function render(el, { api, toast, modal }) {
       ];
       if (change.category) headBits.push(pill(change.category.replace("_", "-"), CATEGORY_TONE[change.category] ?? ""));
       if (change.reused) headBits.push(pill("reused — no rebuild", "violet"));
-      if (change.impacted_columns.length) headBits.push(h("span", { class: "sub" }, `+ ${change.impacted_columns.join(", ")}`));
+      if (change.impacted_columns.length) {
+        const mark = change.category === "non_breaking" ? "+" : "~";
+        headBits.push(h("span", { class: "sub" }, `${mark} ${change.impacted_columns.join(", ")}`));
+      }
 
       const card = h("div", { class: "card" });
       const detail = h("div", { class: "card-body" });

{interlaced-2.8.4 → interlaced-2.8.6}/src/interlace/service/ui/js/views/system.js

@@ -116,7 +116,7 @@ export async function render(el, { api, go, toast, modal, token }) {
           schedules,
           {
             empty: "no scheduled models",
-            hint: "add schedule: {cron: …}, {every: …}, {watch: …}, {on_change: column}, {fresh: \"column 2h\"}, or {webhook: name}",
+            hint: "add schedule: {cron: …}, {every: …}, {watch: …}, {on_change: column}, {fresh: \"column 2h\"}, {after: model}, or {webhook: name}",
           },
         ),
       );

interlaced-2.8.6/src/interlace/state/advisory.py

@@ -0,0 +1,101 @@
+"""Cross-process advisory locks stored in the control-plane database.
+
+SQLite takes the lock inside ``BEGIN IMMEDIATE``, which serialises writers.
+Postgres does not, so the same decision is one conditional upsert: the row
+changes only when this owner already holds it or the lease has expired.
+"""
+
+from __future__ import annotations
+
+import time as _time
+from datetime import UTC, datetime, timedelta
+
+from interlace.state.conn import ControlDb
+
+
+class AdvisoryLockStore:
+    """Advisory locks on one control-plane connection."""
+
+    def __init__(self, db: ControlDb) -> None:
+        self._db = db
+
+    async def acquire_lock(self, name: str, *, owner: str, lease_seconds: float = 180.0, timeout: float = 60.0) -> bool:
+        """Take (or renew, if already owned) a named advisory lock. Returns False on timeout."""
+        return await self._db.io(self._acquire_lock_sync, name, owner, lease_seconds, timeout)
+
+    def _acquire_lock_sync(self, name: str, owner: str, lease_seconds: float, timeout: float) -> bool:
+        deadline = _time.monotonic() + max(0.0, timeout)
+        while True:
+            if self._try_acquire(name, owner, lease_seconds):
+                return True
+            if _time.monotonic() >= deadline:
+                return False
+            _time.sleep(0.05)
+
+    def _try_acquire(self, name: str, owner: str, lease_seconds: float) -> bool:
+        with self._db.lock:
+            if self._db.dialect == "postgres":
+                return self._try_acquire_postgres(name, owner, lease_seconds)
+            return self._try_acquire_sqlite(name, owner, lease_seconds)
+
+    def _try_acquire_sqlite(self, name: str, owner: str, lease_seconds: float) -> bool:
+        self._db.conn.execute("BEGIN IMMEDIATE")
+        try:
+            now = datetime.now(UTC)
+            row = self._db.conn.execute(
+                "SELECT owner, expires_at FROM advisory_locks WHERE name = ?", (name,)
+            ).fetchone()
+            held = row is not None and datetime.fromisoformat(row["expires_at"]) > now
+            if held and row["owner"] != owner:
+                self._db.conn.commit()
+                return False
+            expires = (now + timedelta(seconds=lease_seconds)).isoformat()
+            self._db.conn.execute(
+                "INSERT INTO advisory_locks (name, owner, expires_at) VALUES (?, ?, ?) "
+                "ON CONFLICT(name) DO UPDATE SET owner = excluded.owner, expires_at = excluded.expires_at",
+                (name, owner, expires),
+            )
+            self._db.conn.commit()
+            return True
+        except BaseException:
+            self._db.conn.rollback()
+            raise
+
+    def _try_acquire_postgres(self, name: str, owner: str, lease_seconds: float) -> bool:
+        now = datetime.now(UTC)
+        expires = (now + timedelta(seconds=lease_seconds)).isoformat()
+        # One statement. A lost UPDATE matches nothing, so two sessions cannot both observe a win.
+        # Compare the lease as timestamptz: the stored text is ISO-8601, which does not sort as text.
+        row = self._db.conn.execute(
+            "INSERT INTO advisory_locks (name, owner, expires_at) VALUES (?, ?, ?) "
+            "ON CONFLICT(name) DO UPDATE SET owner = excluded.owner, expires_at = excluded.expires_at "
+            "WHERE advisory_locks.owner = excluded.owner "
+            "OR advisory_locks.expires_at::timestamptz <= ?::timestamptz "
+            "RETURNING owner",
+            (name, owner, expires, now.isoformat()),
+        ).fetchone()
+        return row is not None and row["owner"] == owner
+
+    async def renew_lock(self, name: str, *, owner: str, lease_seconds: float = 180.0) -> bool:
+        """Extend a lock only if ``owner`` still holds it. Returns False if lost."""
+        return await self._db.io(self.renew_lock_sync, name, owner, lease_seconds)
+
+    def renew_lock_sync(self, name: str, owner: str, lease_seconds: float) -> bool:
+        """Extend the lock off the event loop. False when ``owner`` no longer holds it."""
+        expires = (datetime.now(UTC) + timedelta(seconds=lease_seconds)).isoformat()
+        with self._db.lock:
+            cursor = self._db.conn.execute(
+                "UPDATE advisory_locks SET expires_at = ? WHERE name = ? AND owner = ?",
+                (expires, name, owner),
+            )
+            self._db.conn.commit()
+            return cursor.rowcount > 0
+
+    async def release_lock(self, name: str, *, owner: str) -> None:
+        """Drop a lock if ``owner`` still holds it (no-op otherwise)."""
+        await self._db.io(self._release_lock_sync, name, owner)
+
+    def _release_lock_sync(self, name: str, owner: str) -> None:
+        with self._db.lock:
+            self._db.conn.execute("DELETE FROM advisory_locks WHERE name = ? AND owner = ?", (name, owner))
+            self._db.conn.commit()

interlaced-2.8.6/src/interlace/state/conn.py

@@ -0,0 +1,83 @@
+"""One connection shared by every control-plane store.
+
+SQLite is the default. ``connect_postgres`` opens the same stores on Postgres.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sqlite3
+import threading
+from collections.abc import Callable, Sequence
+from typing import Any, Protocol, TypeVar
+
+from interlace.state.schema import _migrate
+
+_R = TypeVar("_R")
+
+
+class _Cursor(Protocol):
+    lastrowid: int
+    rowcount: int
+
+    def fetchone(self) -> Any: ...
+
+    def fetchall(self) -> Sequence[Any]: ...
+
+
+class ConnLike(Protocol):
+    """The slice of ``sqlite3.Connection`` the stores use. Postgres implements it too."""
+
+    def execute(self, sql: str, parameters: Any = ..., /) -> _Cursor: ...
+
+    def executemany(self, sql: str, seq_of_parameters: Any, /) -> _Cursor: ...
+
+    def commit(self) -> None: ...
+
+    def rollback(self) -> None: ...
+
+    def close(self) -> None: ...
+
+
+class ControlDb:
+    """The single control-plane connection. Stores take this; they do not open their own.
+
+    The default is a SQLite file. ``connect_postgres`` is the same stores on a
+    Postgres schema (``state_url``).
+    """
+
+    def __init__(self, connection: ConnLike, *, dialect: str = "sqlite") -> None:
+        self.conn = connection
+        self.lock = threading.Lock()
+        self.dialect = dialect
+
+    @staticmethod
+    def connect(path: str) -> sqlite3.Connection:
+        conn = sqlite3.connect(path, check_same_thread=False)
+        conn.row_factory = sqlite3.Row
+        conn.execute("PRAGMA journal_mode = WAL")
+        conn.execute("PRAGMA synchronous = NORMAL")
+        conn.execute("PRAGMA foreign_keys = ON")
+        conn.execute("PRAGMA busy_timeout = 5000")  # CLI + daemon share this file: wait, don't error
+        conn.execute("PRAGMA cache_size = -65536")
+        _migrate(conn)
+        return conn
+
+    @staticmethod
+    def connect_postgres(dsn: str, schema: str = "interlace") -> ConnLike:
+        from interlace.state.pg import connect, migrate
+
+        conn = connect(dsn, schema)
+        try:
+            migrate(conn, schema)
+        except Exception:
+            conn.close()
+            raise
+        return conn
+
+    async def io(self, fn: Callable[..., _R], /, *args: Any, **kwargs: Any) -> _R:
+        """The one worker-thread entry. Sync methods keep the connection lock."""
+        return await asyncio.to_thread(fn, *args, **kwargs)
+
+    async def close(self) -> None:
+        await self.io(self.conn.close)

{interlaced-2.8.4 → interlaced-2.8.6}/src/interlace/state/events.py

@@ -49,8 +49,8 @@ class EventLogStore:
         with self._db.lock:
             rows = self._db.conn.execute(
                 "SELECT seq, ts, type, entity, payload FROM event_log "
-                "WHERE json_extract(payload, '$.run') = ? ORDER BY seq",
-                (run_id,),
+                "WHERE CAST(json_extract(payload, '$.run') AS TEXT) = ? ORDER BY seq",
+                (str(run_id),),
             ).fetchall()
         return [self._event_row(row) for row in rows]
 

{interlaced-2.8.4 → interlaced-2.8.6}/src/interlace/state/locks.py

@@ -1,10 +1,10 @@
 """Cross-process advisory locks for warehouse-mutating work.
 
 CLI ``apply`` / ``run`` and the daemon (HTTP apply, stream flush, scheduler drain,
-gc, env drop/rollback) all share one SQLite state file. An in-process
-``asyncio.Lock`` cannot serialise those writers — this module does, via
-:meth:`AdvisoryLockStore.acquire_lock` with a heartbeat while the critical
-section runs.
+gc, env drop/rollback) share one control plane: the SQLite state file, or the
+Postgres schema from ``state_url``. An in-process ``asyncio.Lock`` cannot
+serialise those writers — this module does, via :meth:`AdvisoryLockStore.acquire_lock`
+with a heartbeat while the critical section runs.
 """
 
 from __future__ import annotations