interlaced 2.8.4__tar.gz → 2.8.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlaced
-Version: 2.8.4
+Version: 2.8.7
 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.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "interlaced"
-version = "2.8.4"
+version = "2.8.7"
 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.7}/src/interlace/cli/operate.py

@@ -288,7 +288,7 @@ def serve(
     apply_on_start: bool = typer.Option(
         True,
         "--apply/--no-apply",
-        help="Apply the project once at startup. --no-apply serves the warehouse as it is.",
+        help="Apply once at startup, while the API is already listening. --no-apply serves the warehouse as it is.",
     ),
     allow_open: bool = typer.Option(
         False,
@@ -299,7 +299,8 @@ def serve(
     """Run the interlace daemon: HTTP API + scheduler in one process (requires the `service` extra).
 
     Use --no-scheduler for an API-only process (run `interlace scheduler` separately).
-    The project is applied once before the loops start; pass --no-apply to skip that.
+    The API listens immediately. The project is applied once at startup, before the
+    scheduler loop; pass --no-apply to skip that. Writes return 503 until the apply finishes.
     A `cdc:` block in the project config is read here: each Postgres slot appends into its stream.
     """
     try:

{interlaced-2.8.4 → interlaced-2.8.7}/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.7}/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.7}/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.7}/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.7}/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.7/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.7/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.7}/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.7}/src/interlace/service/app.py

@@ -19,7 +19,7 @@ from litestar.static_files import create_static_files_router
 from interlace import __version__
 from interlace.exceptions import BreakingPlanError, LockError
 from interlace.service.auth import auth_guard
-from interlace.service.lifespan import project_lifespan
+from interlace.service.lifespan import project_lifespan, startup_guard
 from interlace.service.routes.admin import (
     delete_apikey,
     get_apikeys,
@@ -90,7 +90,8 @@ def create_app(
     ``scheduler=True`` makes this the combined daemon: the HTTP API plus a
     background scheduler loop (tick triggers, drain the run queue) in one
     process — the default for ``interlace serve``. ``apply_on_start`` applies the
-    project once before the loops start; the ``serve`` command turns it on.
+    project once while the API is already accepting connections; writes get
+    503 until that apply finishes. The ``serve`` command turns it on.
     ``quack`` (a
     ``quack:<host>:<port>`` URI) additionally serves the warehouse over the
     quack protocol so other processes — CLI runs, ad-hoc DuckDB clients —
@@ -220,7 +221,7 @@ def create_app(
             stream_events,
         ],
         lifespan=[lifespan],
-        guards=[auth_guard],
+        guards=[auth_guard, startup_guard],
         openapi_config=OpenAPIConfig(
             title="interlace",
             version=__version__,

{interlaced-2.8.4 → interlaced-2.8.7}/src/interlace/service/lifespan.py

@@ -17,7 +17,9 @@ from pathlib import Path
 from typing import cast
 
 from litestar import Litestar
-from litestar.exceptions import ImproperlyConfiguredException
+from litestar.connection import ASGIConnection
+from litestar.exceptions import ImproperlyConfiguredException, ServiceUnavailableException
+from litestar.handlers.base import BaseRouteHandler
 
 from interlace.graph.column_lineage import column_lineage
 from interlace.project import Project
@@ -38,6 +40,21 @@ from interlace.streaming.materializer import (
 )
 
 
+async def startup_guard(connection: ASGIConnection, _route_handler: BaseRouteHandler) -> None:
+    """Refuse writes until the startup apply has finished.
+
+    The socket is open while that apply runs, so a client gets this response
+    instead of a refused connection. Reads stay available.
+    """
+    status = getattr(connection.app.state, "startup_status", "ok")
+    if status == "ok" or connection.scope.get("method", "GET") in ("GET", "HEAD", "OPTIONS"):
+        return
+    if status == "starting":
+        raise ServiceUnavailableException(detail="startup apply is still running")
+    detail = getattr(connection.app.state, "startup_error", "") or "startup apply failed"
+    raise ServiceUnavailableException(detail=detail)
+
+
 def project_lifespan(  # noqa: C901
     root: Path | str,
     environment: str,
@@ -140,6 +157,10 @@ def project_lifespan(  # noqa: C901
 
         if streams:
             app.state.flush_wanted.set()  # catch up anything durable but unflushed at last shutdown
+        # "starting" until the first apply finishes. The socket opens at the yield
+        # below, so clients reach /health instead of a refused connection.
+        app.state.startup_status = "starting" if apply_on_start else "ok"
+        app.state.startup_error = ""
 
         async def shutdown_watch() -> None:
             """End every open SSE stream the moment uvicorn begins shutting down.
@@ -159,16 +180,36 @@ def project_lifespan(  # noqa: C901
                 with contextlib.suppress(asyncio.QueueFull):
                     subscriber.put_nowait(None)
 
-        if apply_on_start:
-            await startup_apply(app.state)
+        flusher_task: asyncio.Task[None] | None = None
+        loop_task: asyncio.Task[None] | None = None
+        cdc_task: asyncio.Task[None] | None = None
+
+        async def open_service() -> None:
+            """Apply first, then the loops. The listen socket is already open."""
+            nonlocal flusher_task, loop_task, cdc_task
+            try:
+                if apply_on_start:
+                    logger.info("startup apply running; the API is accepting connections")
+                    await startup_apply(app.state)
+                app.state.startup_status = "ok"
+            except Exception as exc:
+                app.state.startup_status = "error"
+                app.state.startup_error = str(exc)
+                logger.exception("startup apply failed")
+                server = getattr(app.state, "uvicorn_server", None)
+                if server is not None:
+                    server.should_exit = True
+                return
+            if streams:
+                flusher_task = asyncio.create_task(flusher_loop(app.state, flush_interval=stream_flush_interval))
+            if scheduler:
+                loop_task = asyncio.create_task(scheduler_loop(app.state, interval=scheduler_interval))
+            if project.config.cdc:
+                cdc_task = asyncio.create_task(cdc_loop(app.state))
 
         tail_task = asyncio.create_task(event_tail())
-        flusher_task = (
-            asyncio.create_task(flusher_loop(app.state, flush_interval=stream_flush_interval)) if streams else None
-        )
-        loop_task = asyncio.create_task(scheduler_loop(app.state, interval=scheduler_interval)) if scheduler else None
-        cdc_task = asyncio.create_task(cdc_loop(app.state)) if project.config.cdc else None
         watch_task = asyncio.create_task(shutdown_watch())
+        service_task = asyncio.create_task(open_service())
         try:
             yield
         finally:
@@ -183,6 +224,10 @@ def project_lifespan(  # noqa: C901
             for subscriber in list(app.state.sse_subscribers):
                 with contextlib.suppress(asyncio.QueueFull):
                     subscriber.put_nowait(None)
+            # Stop the opener first so it cannot start a loop after this snapshot.
+            service_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError, Exception):
+                await service_task
             for task in (cdc_task, loop_task, flusher_task, tail_task, watch_task):
                 if task is not None:
                     task.cancel()

{interlaced-2.8.4 → interlaced-2.8.7}/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.7}/src/interlace/service/routes/models.py

@@ -33,7 +33,13 @@ from interlace.service.types import (
 
 @get("/health")
 async def health(state: State) -> dict[str, str]:
-    return {"status": "ok", "version": __version__, "environment": state.environment}
+    status = getattr(state, "startup_status", "ok")
+    body = {"status": status, "version": __version__, "environment": state.environment}
+    if status == "starting":
+        body["detail"] = "startup apply is still running"
+    elif status == "error":
+        body["detail"] = getattr(state, "startup_error", "") or "startup apply failed"
+    return body
 
 
 @get("/", include_in_schema=False)

{interlaced-2.8.4 → interlaced-2.8.7}/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.7}/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.7}/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}",
           },
         ),
       );