@vibesdotdev/platform 0.0.0-stage → 1.0.0-rc.2

package/dist/docs/platform.config.docs.descriptor.js

@@ -0,0 +1,82 @@
+/**
+ * Descriptor for platform.config
+ */
+const platformConfigMarkdown = `---
+title: Platform Configuration
+summary: Platform-layer resources — hosts, hostnames, daemons, processes, deployments, services
+tags: [platform, config, hosts, hostnames, daemons, deployments]
+parent: platform
+order: 2
+---
+
+# Platform Configuration
+
+The platform layer owns infrastructure primitives: hosts (machines that run workloads), hostnames (DNS + TLS), daemons (long-running processes), processes (one-shot or supervised jobs), deployments (versioned releases), and services (named endpoints). All of these are managed through the \`vibes platform\` CLI group and the \`platform\` API client.
+
+## What this provides
+
+- **\`platform\` runtime/client** — \`getVibesPlatformClient(runtime)\` returns the canonical, scope-gated platform API client.
+- **\`platform.hostnames\` worker** — runs DNS verification + ACME certificate issuance for custom hostnames.
+- **Storage manifests** — \`platform.scheduled-tasks\` (cron), \`platform.banners\` (in-app banners).
+- **Logging** — dedicated \`platform\` logger + output for structured platform logs.
+
+## Types and clients
+
+\`\`\`ts
+import { getVibesPlatformClient } from '@vibesdotdev/platform';
+\`\`\`
+
+## Resource model
+
+| Resource | Purpose |
+|---|---|
+| **host** | A registered machine (cloud VM, on-prem server) eligible to run workloads |
+| **hostname** | A DNS name bound to one or more hosts with TLS certificate state |
+| **daemon** | A long-running process supervised by the platform |
+| **process** | An ad-hoc or supervised job (one-shot or recurring) |
+| **deployment** | A versioned release of an app pinned to a host set |
+| **service** | A named endpoint (port + protocol) exposed by a daemon |
+| **scheduled-task** | A cron-style task that fires worker jobs |
+| **banner** | A platform-managed in-app notification banner |
+
+## Commands available
+
+\`\`\`bash
+# High-level status
+vibes platform status                # cluster-wide health
+vibes platform deployments           # list deployments
+vibes platform services              # list registered services
+
+# Resource groups (each is its own subgroup)
+vibes platform hosts list
+vibes platform hostnames list
+vibes platform daemons list
+vibes platform processes list
+vibes platform scheduled-tasks list
+\`\`\`
+
+## Related topics
+
+- [\`platform.scheduled-tasks\`](platform.scheduled-tasks) — cron-style scheduled tasks
+- [\`config.manifests\`](config.manifests) — how platform-level config is loaded
+- [\`workers.queues\`](workers.queues) — worker queues platform jobs land on
+`;
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'platform.config',
+    title: 'Platform Configuration',
+    summary: 'Platform-layer resources — hosts, hostnames, daemons, processes, deployments, services',
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: platformConfigMarkdown
+    },
+    parent: 'platform',
+    order: 2,
+    tags: ['platform', 'config', 'hosts', 'hostnames', 'daemons', 'deployments'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer'],
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=platform.config.docs.descriptor.js.map

package/dist/docs/platform.config.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.config.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/platform.config.docs.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2D9B,CAAC;AAEF,MAAM,UAAU,GAAG;IACjB,IAAI,EAAE,YAAqB;IAC3B,EAAE,EAAE,iBAAiB;IACrB,KAAK,EAAE,wBAAwB;IAC/B,OAAO,EAAE,wFAAwF;IACjG,IAAI,EAAE;QACJ,IAAI,EAAE,UAAmB;QACzB,UAAU,EAAE,KAAc;QAC1B,MAAM,EAAE,sBAAsB;KAC/B;IACD,MAAM,EAAE,UAAU;IAClB,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,CAAC;IAC5E,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAU;IAC3C,QAAQ,EAAE,CAAC,UAAU,CAAU;IAC/B,OAAO,EAAE,IAAI;CACd,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/platform.repositories.docs.descriptor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Descriptor for platform.repositories
+ */
+declare const descriptor: {
+    kind: "docs/topic";
+    id: string;
+    title: string;
+    summary: string;
+    body: {
+        type: "markdown";
+        sourceType: "raw";
+        source: string;
+    };
+    parent: string;
+    order: number;
+    tags: string[];
+    surfaces: readonly ["cli", "web", "in-app"];
+    hardware: readonly ["consumer"];
+    enabled: boolean;
+};
+export default descriptor;
+//# sourceMappingURL=platform.repositories.docs.descriptor.d.ts.map

package/dist/docs/platform.repositories.docs.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.repositories.docs.descriptor.d.ts","sourceRoot":"","sources":["../../src/docs/platform.repositories.docs.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;AA6CH,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;CAiBf,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/platform.repositories.docs.descriptor.js

@@ -0,0 +1,64 @@
+/**
+ * Descriptor for platform.repositories
+ */
+const platformRepositoriesMarkdown = `---
+title: Platform Repositories
+summary: Source-code repositories owned by a user/org — vibes-provisioned or GitHub-connected, owner-scoped CRUD
+tags: [platform, repositories, git, github, vibes]
+parent: platform
+order: 1
+---
+
+# Platform Repositories
+
+A Repository is a first-class platform entity: a source-code repo owned by a user or organization that a Build chat session clones into a code sandbox. Repositories are provider-abstracted from day one along a single axis — \`vibes\` vs \`github\`.
+
+## Entity lifecycle
+
+A Repository's \`status\` moves through:
+
+- **\`provisioning\`** — the row is inserted but its clone URL is not yet resolvable. \`vibes\` repos start here while the git.vibes.dev create is in flight; a follow-up provisioner fills \`cloneUrl\`/\`externalId\`/\`webUrl\` and flips status to \`active\`.
+- **\`active\`** — the clone URL resolves and the repo is usable by a Build session.
+- **\`archived\`** — retained but hidden from selectors.
+- **\`error\`** — provisioning or connect failed; see \`statusMessage\`.
+
+The clone credential is stored by REFERENCE (\`credentialId\` → a PlatformSecret), never the resolved token.
+
+## Provider axis
+
+- **\`vibes\`** — auto-PROVISION a new repo on the internal git host (git.vibes.dev). Until that host endpoint is wired, create DEFERS: the repo lands in \`provisioning\` (non-blocking) and a follow-up provisioner completes it once the host API + \`GIT_VIBES_API_URL\`/token are configured.
+- **\`github\`** — CONNECT an existing repo. The create form supplies \`externalId\` (owner/repo) + \`cloneUrl\`; provision is a passthrough that lands the repo \`active\`. Private clones resolve the connected GitHub account's delegated token at clone time.
+
+## CRUD API
+
+Owner-scoped to the active account or organization. Canonical vibeskit CRUD wire shape (\`{ results }\` / \`{ result }\`).
+
+- **\`GET /api/repositories\`** — list repositories owned by the active account/org.
+- **\`POST /api/repositories\`** — create a repository. \`vibes\` auto-provisions on git.vibes.dev (deferred → \`provisioning\`); \`github\` connects an existing repo (requires \`externalId\` + \`cloneUrl\`).
+- **\`GET /api/repositories/[id]\`** — fetch a single owner-scoped repository.
+- **\`PATCH /api/repositories/[id]\`** — update a repository.
+- **\`DELETE /api/repositories/[id]\`** — delete a repository.
+
+## Related topics
+
+- [\`platform.config\`](platform.config) — platform-level configuration (hosts, hostnames, daemons)
+`;
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'platform.repositories',
+    title: 'Platform Repositories',
+    summary: 'Source-code repositories owned by a user/org — vibes-provisioned or GitHub-connected, owner-scoped CRUD',
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: platformRepositoriesMarkdown
+    },
+    parent: 'platform',
+    order: 3,
+    tags: ['platform', 'repositories', 'git', 'github', 'vibes'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer'],
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=platform.repositories.docs.descriptor.js.map

package/dist/docs/platform.repositories.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.repositories.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/platform.repositories.docs.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,4BAA4B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCpC,CAAC;AAEF,MAAM,UAAU,GAAG;IACjB,IAAI,EAAE,YAAqB;IAC3B,EAAE,EAAE,uBAAuB;IAC3B,KAAK,EAAE,uBAAuB;IAC9B,OAAO,EACL,yGAAyG;IAC3G,IAAI,EAAE;QACJ,IAAI,EAAE,UAAmB;QACzB,UAAU,EAAE,KAAc;QAC1B,MAAM,EAAE,4BAA4B;KACrC;IACD,MAAM,EAAE,UAAU;IAClB,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,UAAU,EAAE,cAAc,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,CAAC;IAC5D,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAU;IAC3C,QAAQ,EAAE,CAAC,UAAU,CAAU;IAC/B,OAAO,EAAE,IAAI;CACd,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/platform.scheduled-tasks.docs.descriptor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Descriptor for platform.scheduled-tasks
+ */
+declare const descriptor: {
+    kind: "docs/topic";
+    id: string;
+    title: string;
+    summary: string;
+    body: {
+        type: "markdown";
+        sourceType: "raw";
+        source: string;
+    };
+    parent: string;
+    order: number;
+    tags: string[];
+    surfaces: readonly ["cli", "web", "in-app"];
+    hardware: readonly ["consumer"];
+    enabled: boolean;
+};
+export default descriptor;
+//# sourceMappingURL=platform.scheduled-tasks.docs.descriptor.d.ts.map

package/dist/docs/platform.scheduled-tasks.docs.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.scheduled-tasks.docs.descriptor.d.ts","sourceRoot":"","sources":["../../src/docs/platform.scheduled-tasks.docs.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAwDH,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;CAgBf,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/platform.scheduled-tasks.docs.descriptor.js

@@ -0,0 +1,75 @@
+/**
+ * Descriptor for platform.scheduled-tasks
+ */
+const platformScheduledTasksMarkdown = `---
+title: Platform Scheduled Tasks
+summary: User-managed cron tasks — schedule, run, list, and audit recurring work
+tags: [platform, scheduled-tasks, cron, scheduler]
+parent: platform
+order: 1
+---
+
+# Platform Scheduled Tasks
+
+Scheduled tasks are user-managed cron entries that run on the platform's worker fleet. Each task carries a schedule expression, a target job id, and optional payload. The platform persists tasks, dispatches them at fire time, and records audit history.
+
+## What this provides
+
+- **\`scheduled-tasks\` storage manifest** — \`platform.scheduled-tasks\` storage record holds task definitions.
+- **Schedule resolution** — workers consult the storage at the configured cadence and enqueue eligible tasks.
+- **CLI surface** — \`vibes platform scheduled-tasks\` for create/list/run/delete.
+- **History** — each fire is logged through the \`platform\` logger output.
+
+## Types and clients
+
+\`\`\`ts
+import { getVibesPlatformClient } from '@vibesdotdev/platform';
+\`\`\`
+
+\`platform.api-client\` exposes scheduled-task CRUD on the canonical runtime/client.
+
+## Commands available
+
+\`\`\`bash
+# List scheduled tasks for the active org
+vibes platform scheduled-tasks list
+vibes platform scheduled-tasks list --json
+
+# Create a new scheduled task
+vibes platform scheduled-tasks create --name "<name>" --schedule "<cron>" --job <job-id>
+
+# Show details for a single task
+vibes platform scheduled-tasks show <task-id>
+
+# Manually trigger a task now (bypassing schedule)
+vibes platform scheduled-tasks run <task-id>
+
+# Delete a task
+vibes platform scheduled-tasks delete <task-id>
+\`\`\`
+
+## Related topics
+
+- [\`platform.config\`](platform.config) — platform-level configuration (hosts, hostnames, daemons)
+- [\`pm.queues\`](pm.queues) — the queue that scheduled tasks dispatch into
+- [\`workers.queues\`](workers.queues) — worker-side scheduling
+`;
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'platform.scheduled-tasks',
+    title: 'Platform Scheduled Tasks',
+    summary: 'User-managed cron tasks — schedule, run, list, and audit recurring work',
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: platformScheduledTasksMarkdown
+    },
+    parent: 'platform',
+    order: 1,
+    tags: ['platform', 'scheduled-tasks', 'cron', 'scheduler'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer'],
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=platform.scheduled-tasks.docs.descriptor.js.map

package/dist/docs/platform.scheduled-tasks.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.scheduled-tasks.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/platform.scheduled-tasks.docs.descriptor.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,8BAA8B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDtC,CAAC;AAEF,MAAM,UAAU,GAAG;IACjB,IAAI,EAAE,YAAqB;IAC3B,EAAE,EAAE,0BAA0B;IAC9B,KAAK,EAAE,0BAA0B;IACjC,OAAO,EAAE,yEAAyE;IAClF,IAAI,EAAE;QACJ,IAAI,EAAE,UAAmB;QACzB,UAAU,EAAE,KAAc;QAC1B,MAAM,EAAE,8BAA8B;KACvC;IACD,MAAM,EAAE,UAAU;IAClB,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,UAAU,EAAE,iBAAiB,EAAE,MAAM,EAAE,WAAW,CAAC;IAC1D,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAU;IAC3C,QAAQ,EAAE,CAAC,UAAU,CAAU;IAC/B,OAAO,EAAE,IAAI;CACd,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/fleet-events/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `@vibesdotdev/platform/fleet-events` — the platform-side projection of fleet
+ * host lifecycle events (lane L6c — platform.md §Package and surface layout).
+ *
+ * Platform owns host *records*; fleet owns host *lifecycle*. Fleet emits
+ * `FleetHostEvent`s (fleet/src/boundary/platform-events.ts); platform
+ * subscribes and projects them into its own host row through an injected
+ * `PlatformHostRecordWriter`. This is the *only* place the platform ↔ fleet
+ * boundary is crossed, and the arrow only ever points fleet → platform.
+ */
+export { projectFleetEvent, subscribeFleetHostEvents, type PlatformHostRecordWriter, type HostLifecyclePatch } from './subscriber.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/fleet-events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fleet-events/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACN,iBAAiB,EACjB,wBAAwB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,MAAM,iBAAiB,CAAC"}

package/dist/fleet-events/index.js

@@ -0,0 +1,12 @@
+/**
+ * `@vibesdotdev/platform/fleet-events` — the platform-side projection of fleet
+ * host lifecycle events (lane L6c — platform.md §Package and surface layout).
+ *
+ * Platform owns host *records*; fleet owns host *lifecycle*. Fleet emits
+ * `FleetHostEvent`s (fleet/src/boundary/platform-events.ts); platform
+ * subscribes and projects them into its own host row through an injected
+ * `PlatformHostRecordWriter`. This is the *only* place the platform ↔ fleet
+ * boundary is crossed, and the arrow only ever points fleet → platform.
+ */
+export { projectFleetEvent, subscribeFleetHostEvents } from "./subscriber.js";
+//# sourceMappingURL=index.js.map

package/dist/fleet-events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/fleet-events/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACN,iBAAiB,EACjB,wBAAwB,EAGxB,MAAM,iBAAiB,CAAC"}

package/dist/fleet-events/subscriber.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Platform-side fleet event subscriber (lane L6c — platform.md §Target design).
+ *
+ * **Platform owns host *records*; fleet owns host *lifecycle*. Fleet writes
+ * (emits events); platform reads (projects them into its own host row).** This
+ * module is the single place that boundary is crossed, and it is deliberately
+ * thin: it maps each `FleetHostEvent` to a record write platform already owns,
+ * through an injected `PlatformHostRecordWriter` port. The package owns the
+ * *projection logic*; `apps/platform-web/src/server/` owns the Drizzle-backed
+ * *persistence* the port resolves to (per platform/SPEC.md "Does not
+ * own" — app-local tables live in the app).
+ *
+ * The crucial invariant: **platform never *commands* fleet.** There is no
+ * `platform.hosts.heartbeat()` that fleet calls; instead fleet emits
+ * `host.health-changed` and platform *projects* it. The arrow only ever points
+ * fleet → platform. This module imports the event *contract* from
+ * `@vibesdotdev/platform/fleets` (types-only — no runtime cycle, fleet never imports
+ * platform) and calls *only* the writer port — it has no handle on a fleet
+ * lifecycle method to call back into (platform.md acceptance #2: "no write-back
+ * arrow").
+ *
+ * Fleet's published contract (fleet/src/boundary/platform-events.ts)
+ * carries three lifecycle events, each keyed to the platform record by
+ * `hostRecordId` (the FK into `hostSchema.id`):
+ *   - `host.registered`              the daemon committed → record `pending`.
+ *   - `host.health-changed`          reachability transitioned → liveness +
+ *                                    billing meter.
+ *   - `host.capabilities-discovered` discovery resolved → store capabilities.
+ *
+ * Note: fleet's `host.health-changed` carries a `FleetHostHealth` *reachability*
+ * enum (`unknown|reachable|degraded|unreachable`), NOT a raw platform
+ * `HostHeartbeat` — that is the actual L6a contract, which differs from the
+ * illustrative sketch in platform.md. The projector maps reachability onto the
+ * record's liveness column and feeds the billing anchor off the same signal,
+ * so billing still meters off liveness (acceptance #4) — it just reads liveness
+ * via the event rather than via a direct heartbeat command.
+ */
+import type { FleetHostEvent, FleetHostHealth } from '@vibesdotdev/platform/fleets';
+import { type CaughtFailure, type RuntimeRef } from '@vibesdotdev/kernel';
+import { type HostCapabilities, type HostState } from '../schemas/hosts/common.ts';
+/**
+ * The record-write seam platform exposes to the projector. The app binds this
+ * to its Drizzle-backed host table; the package owns the projection, the app
+ * owns the persistence (platform.md §3 — "the package owns the projection
+ * logic, the app owns the persistence").
+ *
+ * Every method is a *record* write platform already owns. There is no method
+ * that writes back into fleet — the port is read-side-only by construction.
+ */
+export interface PlatformHostRecordWriter {
+    /**
+     * Apply a lifecycle-derived patch to the host *record* identified by its
+     * platform `hostSchema.id` (the event's `hostRecordId` FK). The patch is
+     * guarded: `expectStatusIn`, when present, instructs the writer to apply the
+     * `status` transition only if the row's current status is in the set. This is
+     * how the projector honors the heartbeat race guard (platform.md acceptance
+     * #3: a liveness event for a `provisioning` host is ignored) *without* reading
+     * the row itself — the projector stays pure, the writer enforces the clamp.
+     */
+    applyLifecycle(hostRecordId: string, patch: HostLifecyclePatch): Promise<void>;
+    /**
+     * Advance the host's `lastBilledAt` uptime anchor in response to an observed
+     * liveness signal (platform.md acceptance #4 — billing meters off liveness via
+     * the event, never via a direct heartbeat command). Called only when the
+     * event asserts the host is reachable.
+     */
+    recordBillingLiveness(hostRecordId: string, observedAt: string): Promise<void>;
+}
+/**
+ * A lifecycle-derived patch onto the host *record*. Only columns platform owns
+ * appear here; fleet never names a platform column directly — the projector
+ * translates the event into this record-shaped patch.
+ */
+export interface HostLifecyclePatch {
+    /**
+     * The target `Host.status`. Omitted when the event carries no status
+     * transition (e.g. `host.capabilities-discovered`, or a non-`reachable`
+     * health change that records health without advancing liveness).
+     */
+    status?: HostState;
+    /**
+     * Guard for `status`: apply the transition only if the row's current status
+     * is in this set. The writer drops the `status` change (but may still apply
+     * the rest of the patch) when the current status is outside the set. Absent =
+     * unconditional. The projector sets this to partition transitions by owner so
+     * fleet liveness can never clobber a platform-owned edge (provision-settle,
+     * operator retirement).
+     */
+    expectStatusIn?: readonly HostState[];
+    /** Discovered/observed capabilities to store on the record. */
+    capabilities?: HostCapabilities;
+    /** The fleet-observed reachability health, stored for routing/UX. */
+    health?: FleetHostHealth;
+    /** ISO-8601 timestamp of the liveness observation, for `lastHeartbeatAt`. */
+    lastHeartbeatAt?: string;
+    /**
+     * The runtime-side identity (`fleet/host` descriptor id) and routing handle
+     * carried by `host.registered`, stored as routing metadata on the record.
+     */
+    fleetHostId?: string;
+    /** The `runtime/rpc` descriptor id naming this host's reachable runtime. */
+    rpcId?: string;
+    /** How the host entered the fleet registry (provisioned vs discovered). */
+    origin?: 'provisioned' | 'discovered';
+}
+/**
+ * Project a single `FleetHostEvent` into platform's host record via the writer
+ * port. This is the only boundary crossing in platform; it never calls back into
+ * fleet (it has no fleet handle to call — the import is types-only). Each event
+ * maps to exactly one record write (`host.health-changed` additionally meters
+ * billing off the same liveness signal).
+ *
+ * The exhaustive `switch` over the discriminated union means a new fleet event
+ * type fails the build here until it is given a projection — the boundary is the
+ * compiler's enforcement point.
+ */
+export declare function projectFleetEvent(event: FleetHostEvent, writer: PlatformHostRecordWriter): Promise<void>;
+/**
+ * Subscribe the platform projector to a fleet host-event source. `subscribe` is
+ * the fleet emitter's `subscribe` (`FleetHostEventEmitter.subscribe` from
+ * `@vibesdotdev/platform/fleets`) — platform receives events and projects them; it returns
+ * a stop handle that also removes lifecycle cleanup. Async projection failures are parsed to a
+ * `CaughtFailure` at this boundary and forwarded to the required `onError`
+ * sink, so a transient record-write failure neither throws into the
+ * synchronous emitter (which isolates throwing subscribers) nor goes silent:
+ * the sink is required, so there is no unsunk path.
+ *
+ * This is the wiring `apps/platform-web` (server) uses:
+ *
+ * ```ts
+ * import { subscribeFleetHostEvents } from '@vibesdotdev/platform/fleet-events';
+ * subscribeFleetHostEvents(fleetEmitter.subscribe, platformHostRecordWriter, (failure, event) => {
+ * 	reportProjectionFailure(failure, event);
+ * }, runtime);
+ * ```
+ */
+export declare function subscribeFleetHostEvents(subscribe: (listener: (event: FleetHostEvent) => void) => () => void, writer: PlatformHostRecordWriter, onError: (failure: CaughtFailure, event: FleetHostEvent) => void, runtime: RuntimeRef): () => void;
+//# sourceMappingURL=subscriber.d.ts.map

package/dist/fleet-events/subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriber.d.ts","sourceRoot":"","sources":["../../src/fleet-events/subscriber.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EACX,cAAc,EACd,eAAe,EACf,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAA2E,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACnJ,OAAO,EAA0B,KAAK,gBAAgB,EAAE,KAAK,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAE3G;;;;;;;;GAQG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;;;;;;OAQG;IACH,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/E;;;;;OAKG;IACH,qBAAqB,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/E;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IACtC,+DAA+D;IAC/D,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC,qEAAqE;IACrE,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,MAAM,CAAC,EAAE,aAAa,GAAG,YAAY,CAAC;CACtC;AA4BD;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACtC,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,wBAAwB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAQf;AA+FD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,wBAAwB,CACvC,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,KAAK,MAAM,IAAI,EACpE,MAAM,EAAE,wBAAwB,EAChC,OAAO,EAAE,CAAC,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,cAAc,KAAK,IAAI,EAChE,OAAO,EAAE,UAAU,GACjB,MAAM,IAAI,CA+BZ"}