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

package/dist/fleets/pairing/direct/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../../../src/fleets/pairing/direct/ids.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACzF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAEzE,qFAAqF;AACrF,MAAM,WAAW,uBAAwB,SAAQ,qBAAqB;IACrE,MAAM,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,GAAG,qBAAqB,CAAC;CACjE;AAED,sEAAsE;AACtE,eAAO,MAAM,4BAA4B,2DAExC,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,6BAA6B,+DAEzC,CAAC;AACF,eAAO,MAAM,uBAAuB,iBAAiB,CAAC;AAEtD,mDAAmD;AACnD,eAAO,MAAM,2BAA2B,2BAA2B,CAAC;AAEpE,2EAA2E;AAC3E,MAAM,WAAW,eAAe;IAC/B;;;OAGG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uDAAuD;IACvD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,mBAAmB,CAAC;IACpC,wDAAwD;IACxD,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC,aAAa,CAAC,CAAC;CAC3D"}

package/dist/fleets/pairing/direct/ids.js

@@ -0,0 +1,15 @@
+/**
+ * Static descriptor identity + port types for the direct-IP discovery adapter.
+ *
+ * Lives in a separate identity module so callers can use the stable adapter id
+ * and input types without importing implementation code.
+ */
+import * as z from 'zod/v4';
+/** Validate discovery ports returned by a selected implementation. */
+export const DirectDiscoveryAdapterSchema = z.custom((value) => z.object({ id: z.string().min(1), discover: z.function() }).safeParse(value).success);
+/** The implementation port advertised by the direct-host input protocol. */
+export const DirectDiscoveryProviderSchema = z.custom((value) => z.object({ id: z.string().min(1), discover: z.function(), create: z.function() }).safeParse(value).success);
+export const DIRECT_HOSTS_INPUT_KIND = 'direct-hosts';
+/** Adapter id — the `fleet/discovery` impl key. */
+export const DIRECT_DISCOVERY_ADAPTER_ID = 'fleet/discovery/direct';
+//# sourceMappingURL=ids.js.map

package/dist/fleets/pairing/direct/ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.js","sourceRoot":"","sources":["../../../../src/fleets/pairing/direct/ids.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAS5B,sEAAsE;AACtE,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CAAwB,CAAC,KAAK,EAAE,EAAE,CACrF,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO,CACpF,CAAC;AAEF,4EAA4E;AAC5E,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CAA0B,CAAC,KAAK,EAAE,EAAE,CACxF,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO,CAC1G,CAAC;AACF,MAAM,CAAC,MAAM,uBAAuB,GAAG,cAAc,CAAC;AAEtD,mDAAmD;AACnD,MAAM,CAAC,MAAM,2BAA2B,GAAG,wBAAwB,CAAC"}

package/dist/fleets/pairing/direct/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @vibesdotdev/platform/fleets/pairing/direct — direct-IP discovery adapter (L6b).
+ *
+ * `fleet/discovery/direct`: an operator-supplied `host:port` / `https://` origin
+ * becomes a `runtime/rpc` target in the reachable-runtime registry. The simplest
+ * discovery adapter — no socket, no cloud call.
+ */
+export { type DirectHostInput, type DirectDiscoveryProvider, DIRECT_HOSTS_INPUT_KIND, DirectDiscoveryAdapterSchema, DirectDiscoveryProviderSchema, createDirectDiscoveryAdapter, buildDirectRpcDescriptor, parseDirectAddress, DIRECT_DISCOVERY_ADAPTER_ID } from './direct-discovery.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/fleets/pairing/direct/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/fleets/pairing/direct/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACN,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,uBAAuB,EACvB,4BAA4B,EAC5B,6BAA6B,EAC7B,4BAA4B,EAC5B,wBAAwB,EACxB,kBAAkB,EAClB,2BAA2B,EAC3B,MAAM,uBAAuB,CAAC"}

package/dist/fleets/pairing/direct/index.js

@@ -0,0 +1,9 @@
+/**
+ * @vibesdotdev/platform/fleets/pairing/direct — direct-IP discovery adapter (L6b).
+ *
+ * `fleet/discovery/direct`: an operator-supplied `host:port` / `https://` origin
+ * becomes a `runtime/rpc` target in the reachable-runtime registry. The simplest
+ * discovery adapter — no socket, no cloud call.
+ */
+export { DIRECT_HOSTS_INPUT_KIND, DirectDiscoveryAdapterSchema, DirectDiscoveryProviderSchema, createDirectDiscoveryAdapter, buildDirectRpcDescriptor, parseDirectAddress, DIRECT_DISCOVERY_ADAPTER_ID } from "./direct-discovery.js";
+//# sourceMappingURL=index.js.map

package/dist/fleets/pairing/direct/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/fleets/pairing/direct/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAGN,uBAAuB,EACvB,4BAA4B,EAC5B,6BAA6B,EAC7B,4BAA4B,EAC5B,wBAAwB,EACxB,kBAAkB,EAClB,2BAA2B,EAC3B,MAAM,uBAAuB,CAAC"}

package/dist/fleets/pairing/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @vibesdotdev/platform/fleets/pairing — the fleet discovery adapter base (L6b / fleet.md §4.6).
+ *
+ * Defines the `FleetDiscoveryAdapter` contract, the discovery→registry bridge
+ * (`registerDiscovered`), and the `fleet/discovery` adapter kind. Concrete
+ * adapters live in `@vibesdotdev/platform/fleets/pairing-{direct,platform,mdns}`.
+ *
+ * The spine of this lane (correction #4): discovery has NO teardown — this base
+ * contract deliberately omits `destroy`. Provisioning (which owns a billable
+ * resource) carries one; the two share the `runtime/rpc` output contract but not
+ * a lifecycle.
+ */
+export { type FleetDiscoveryAdapter, registerDiscovered, toDiscoveredEntry, DEFAULT_DISCOVERED_TTL_SECONDS } from '@vibesdotdev/platform/fleets';
+export { type FleetDiscoveryDescriptor, type FleetDiscoveryInstance, FleetDiscoveryDescriptorSchema, fleetDiscoveryKind } from './kinds/discovery.kind.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/fleets/pairing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fleets/pairing/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACN,KAAK,qBAAqB,EAC1B,kBAAkB,EAClB,iBAAiB,EACjB,8BAA8B,EAC9B,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACN,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,8BAA8B,EAC9B,kBAAkB,EAClB,MAAM,2BAA2B,CAAC"}

package/dist/fleets/pairing/index.js

@@ -0,0 +1,15 @@
+/**
+ * @vibesdotdev/platform/fleets/pairing — the fleet discovery adapter base (L6b / fleet.md §4.6).
+ *
+ * Defines the `FleetDiscoveryAdapter` contract, the discovery→registry bridge
+ * (`registerDiscovered`), and the `fleet/discovery` adapter kind. Concrete
+ * adapters live in `@vibesdotdev/platform/fleets/pairing-{direct,platform,mdns}`.
+ *
+ * The spine of this lane (correction #4): discovery has NO teardown — this base
+ * contract deliberately omits `destroy`. Provisioning (which owns a billable
+ * resource) carries one; the two share the `runtime/rpc` output contract but not
+ * a lifecycle.
+ */
+export { registerDiscovered, toDiscoveredEntry, DEFAULT_DISCOVERED_TTL_SECONDS } from '@vibesdotdev/platform/fleets';
+export { FleetDiscoveryDescriptorSchema, fleetDiscoveryKind } from "./kinds/discovery.kind.js";
+//# sourceMappingURL=index.js.map

package/dist/fleets/pairing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/fleets/pairing/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAEN,kBAAkB,EAClB,iBAAiB,EACjB,8BAA8B,EAC9B,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAGN,8BAA8B,EAC9B,kBAAkB,EAClB,MAAM,2BAA2B,CAAC"}

package/dist/fleets/pairing/kinds/discovery.kind.d.ts

@@ -0,0 +1,55 @@
+/**
+ * `fleet/discovery` — the discovery-adapter kind (fleet.md §4.6, §5).
+ *
+ * A discovery adapter is the runtime-kind expression of "a way to find
+ * already-running reachable runtimes." Each concrete adapter
+ * (`fleet/discovery/{direct,platform,mdns}`) registers an impl under this kind;
+ * the impl is a {@link FleetDiscoveryAdapter} (its `discover()` yields
+ * `runtime/rpc` descriptors — the shared output contract).
+ *
+ * This kind carries NO transport/target/auth — those live on the `runtime/rpc`
+ * descriptors the adapter EMITS, never on the adapter itself. The discovery kind
+ * owns only *how to find*; `runtime/rpc` owns *how to reach* (fleet.md §4.6).
+ */
+import * as z from 'zod/v4';
+import type { FleetDiscoveryAdapter } from '@vibesdotdev/platform/fleets';
+export declare const FleetDiscoveryDescriptorSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hardware: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    capabilityId: z.ZodOptional<z.ZodString>;
+    requiredContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optionalContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    config: z.ZodOptional<z.ZodUnknown>;
+    retention: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        maxAgeDays: z.ZodOptional<z.ZodNumber>;
+        maxEntries: z.ZodOptional<z.ZodNumber>;
+        maxBytes: z.ZodOptional<z.ZodNumber>;
+        cascadeFrom: z.ZodOptional<z.ZodString>;
+        ageField: z.ZodOptional<z.ZodString>;
+        reason: z.ZodString;
+        enforcedBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    kind: z.ZodLiteral<"fleet/discovery">;
+    method: z.ZodString;
+    inputKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    emitsTransport: z.ZodArray<z.ZodEnum<{
+        unix: "unix";
+        tcp: "tcp";
+        http: "http";
+        relay: "relay";
+    }>>;
+}, z.core.$strip>;
+export type FleetDiscoveryDescriptor = z.infer<typeof FleetDiscoveryDescriptorSchema>;
+/**
+ * The discovery kind's impl IS a {@link FleetDiscoveryAdapter}. Resolving a
+ * `fleet/discovery` asset yields the adapter; the consumer drives its
+ * `discover()` into the reachable-runtime registry (via `registerDiscovered`).
+ */
+export type FleetDiscoveryInstance = FleetDiscoveryAdapter;
+export declare const fleetDiscoveryKind: import("@vibesdotdev/kernel").RuntimeKindDescriptorRecord<FleetDiscoveryAdapter>;
+//# sourceMappingURL=discovery.kind.d.ts.map

package/dist/fleets/pairing/kinds/discovery.kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.kind.d.ts","sourceRoot":"","sources":["../../../../src/fleets/pairing/kinds/discovery.kind.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAE1E,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAezC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,qBAAqB,CAAC;AAM3D,eAAO,MAAM,kBAAkB,kFAY7B,CAAC"}

package/dist/fleets/pairing/kinds/discovery.kind.js

@@ -0,0 +1,50 @@
+/**
+ * `fleet/discovery` — the discovery-adapter kind (fleet.md §4.6, §5).
+ *
+ * A discovery adapter is the runtime-kind expression of "a way to find
+ * already-running reachable runtimes." Each concrete adapter
+ * (`fleet/discovery/{direct,platform,mdns}`) registers an impl under this kind;
+ * the impl is a {@link FleetDiscoveryAdapter} (its `discover()` yields
+ * `runtime/rpc` descriptors — the shared output contract).
+ *
+ * This kind carries NO transport/target/auth — those live on the `runtime/rpc`
+ * descriptors the adapter EMITS, never on the adapter itself. The discovery kind
+ * owns only *how to find*; `runtime/rpc` owns *how to reach* (fleet.md §4.6).
+ */
+import * as z from 'zod/v4';
+import { createRuntimeKind } from '@vibesdotdev/kernel/factory/kind';
+import { RuntimeDescriptorSchema } from '@vibesdotdev/kernel/schemas/descriptor';
+export const FleetDiscoveryDescriptorSchema = RuntimeDescriptorSchema.extend({
+    kind: z.literal('fleet/discovery'),
+    /**
+     * The discovery method this adapter implements. Stable, URL-safe; mirrors the
+     * adapter id suffix (`direct` → `fleet/discovery/direct`).
+     */
+    method: z.string().min(1),
+    /** Input protocols supported by this discovery implementation. */
+    inputKinds: z.array(z.string().min(1)).optional(),
+    /**
+     * The transport family the descriptors this adapter emits will carry. A hint
+     * only — the authoritative transport is on each emitted `runtime/rpc`
+     * descriptor's `target`. (`direct` can emit tcp OR http, hence the array.)
+     */
+    emitsTransport: z.array(z.enum(['unix', 'tcp', 'http', 'relay'])).min(1)
+});
+function assertDiscoveryDescriptor(candidate) {
+    FleetDiscoveryDescriptorSchema.parse(candidate);
+}
+export const fleetDiscoveryKind = createRuntimeKind({
+    id: 'fleet/discovery',
+    descriptorSchema: FleetDiscoveryDescriptorSchema,
+    resolve: candidates => {
+        let best;
+        for (const candidate of candidates) {
+            assertDiscoveryDescriptor(candidate);
+            if (!best || (candidate.priority ?? 0) > (best.priority ?? 0))
+                best = candidate;
+        }
+        return best;
+    },
+    contexts: []
+});
+//# sourceMappingURL=discovery.kind.js.map

package/dist/fleets/pairing/kinds/discovery.kind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.kind.js","sourceRoot":"","sources":["../../../../src/fleets/pairing/kinds/discovery.kind.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,uBAAuB,EAA0B,MAAM,wCAAwC,CAAC;AAGzG,MAAM,CAAC,MAAM,8BAA8B,GAAG,uBAAuB,CAAC,MAAM,CAAC;IAC5E,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC;IAClC;;;OAGG;IACH,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACzB,kEAAkE;IAClE,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACjD;;;;OAIG;IACH,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;CACxE,CAAC,CAAC;AAUH,SAAS,yBAAyB,CAAC,SAA4B;IAC9D,8BAA8B,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;AACjD,CAAC;AAED,MAAM,CAAC,MAAM,kBAAkB,GAAG,iBAAiB,CAAmD;IACrG,EAAE,EAAE,iBAAiB;IACrB,gBAAgB,EAAE,8BAA8B;IAChD,OAAO,EAAE,UAAU,CAAC,EAAE;QACrB,IAAI,IAA0C,CAAC;QAC/C,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACpC,yBAAyB,CAAC,SAAS,CAAC,CAAC;YACrC,IAAI,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC;gBAAE,IAAI,GAAG,SAAS,CAAC;QACjF,CAAC;QACD,OAAO,IAAI,CAAC;IACb,CAAC;IACD,QAAQ,EAAE,EAAE;CACZ,CAAC,CAAC"}

package/dist/fleets/pairing/mdns/ids.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Static descriptor identity + port types for the mDNS discovery adapter.
+ *
+ * Lives in a separate identity module so callers can use the stable adapter id
+ * and scanner port types without importing implementation code.
+ */
+import type { RuntimeRpcDescriptor } from '@vibesdotdev/kernel-rpc';
+/** Adapter id — the `fleet/discovery` impl key. */
+export declare const MDNS_DISCOVERY_ADAPTER_ID = "fleet/discovery/mdns";
+/** The mDNS service type fleet runtimes advertise. */
+export declare const VIBES_RPC_MDNS_SERVICE = "_vibes-rpc._tcp";
+/**
+ * A single `_vibes-rpc._tcp` service advertisement as observed on the LAN. The
+ * scanner yields these; the adapter turns each into a `runtime/rpc` descriptor.
+ */
+export interface MdnsServiceAdvertisement {
+    /** The advertised instance name (e.g. `'studio-mini'`) — the descriptor id seed. */
+    readonly instanceName: string;
+    /** Resolved address: an IPv4/IPv6 literal or a `.local` hostname. */
+    readonly host: string;
+    /** Advertised TCP port the rpc server listens on. */
+    readonly port: number;
+    /** Service type — expected `_vibes-rpc._tcp`; carried for assertion. */
+    readonly serviceType?: string;
+    /** mDNS record TTL (seconds). Becomes the registry entry's eviction TTL. */
+    readonly ttlSeconds?: number;
+    /** Optional TXT-record scope hint (substrate/hardware) for resolver bias. */
+    readonly remoteScope?: RuntimeRpcDescriptor['remoteScope'];
+}
+/**
+ * The multicast scanner port. The default impl performs the real socket scan
+ * (capability-gated); tests inject a fixture that yields canned advertisements.
+ * The protocol/adapter never bakes in a concrete socket.
+ */
+export interface MdnsScanner {
+    /** Yield `_vibes-rpc._tcp` advertisements until `signal` aborts. */
+    scan(signal?: AbortSignal): AsyncIterable<MdnsServiceAdvertisement>;
+}
+//# sourceMappingURL=ids.d.ts.map

package/dist/fleets/pairing/mdns/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../../../src/fleets/pairing/mdns/ids.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEpE,mDAAmD;AACnD,eAAO,MAAM,yBAAyB,yBAAyB,CAAC;AAEhE,sDAAsD;AACtD,eAAO,MAAM,sBAAsB,oBAAoB,CAAC;AAExD;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACxC,oFAAoF;IACpF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,qEAAqE;IACrE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qDAAqD;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,6EAA6E;IAC7E,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC,aAAa,CAAC,CAAC;CAC3D;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC3B,oEAAoE;IACpE,IAAI,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,aAAa,CAAC,wBAAwB,CAAC,CAAC;CACpE"}

package/dist/fleets/pairing/mdns/ids.js

@@ -0,0 +1,11 @@
+/**
+ * Static descriptor identity + port types for the mDNS discovery adapter.
+ *
+ * Lives in a separate identity module so callers can use the stable adapter id
+ * and scanner port types without importing implementation code.
+ */
+/** Adapter id — the `fleet/discovery` impl key. */
+export const MDNS_DISCOVERY_ADAPTER_ID = 'fleet/discovery/mdns';
+/** The mDNS service type fleet runtimes advertise. */
+export const VIBES_RPC_MDNS_SERVICE = '_vibes-rpc._tcp';
+//# sourceMappingURL=ids.js.map

package/dist/fleets/pairing/mdns/ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.js","sourceRoot":"","sources":["../../../../src/fleets/pairing/mdns/ids.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,mDAAmD;AACnD,MAAM,CAAC,MAAM,yBAAyB,GAAG,sBAAsB,CAAC;AAEhE,sDAAsD;AACtD,MAAM,CAAC,MAAM,sBAAsB,GAAG,iBAAiB,CAAC"}

package/dist/fleets/pairing/mdns/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @vibesdotdev/platform/fleets/pairing/mdns — mDNS LAN discovery adapter (L6b).
+ *
+ * `fleet/discovery/mdns`: LAN runtimes advertising `_vibes-rpc._tcp` become
+ * `runtime/rpc` tcp targets. The multicast scan is capability-gated and lives
+ * behind an injected scanner port (no real multicast in CI); the tested contract
+ * is the advertisement→descriptor mapping + the adapter shape.
+ */
+export { type MdnsServiceAdvertisement, type MdnsScanner, createMdnsDiscoveryAdapter, createDefaultMdnsScanner, buildMdnsRpcDescriptor, mdnsDescriptorId, mdnsCapabilityAvailable, MDNS_DISCOVERY_ADAPTER_ID, VIBES_RPC_MDNS_SERVICE } from './mdns-discovery.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/fleets/pairing/mdns/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/fleets/pairing/mdns/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACN,KAAK,wBAAwB,EAC7B,KAAK,WAAW,EAChB,0BAA0B,EAC1B,wBAAwB,EACxB,sBAAsB,EACtB,gBAAgB,EAChB,uBAAuB,EACvB,yBAAyB,EACzB,sBAAsB,EACtB,MAAM,qBAAqB,CAAC"}

package/dist/fleets/pairing/mdns/index.js

@@ -0,0 +1,10 @@
+/**
+ * @vibesdotdev/platform/fleets/pairing/mdns — mDNS LAN discovery adapter (L6b).
+ *
+ * `fleet/discovery/mdns`: LAN runtimes advertising `_vibes-rpc._tcp` become
+ * `runtime/rpc` tcp targets. The multicast scan is capability-gated and lives
+ * behind an injected scanner port (no real multicast in CI); the tested contract
+ * is the advertisement→descriptor mapping + the adapter shape.
+ */
+export { createMdnsDiscoveryAdapter, createDefaultMdnsScanner, buildMdnsRpcDescriptor, mdnsDescriptorId, mdnsCapabilityAvailable, MDNS_DISCOVERY_ADAPTER_ID, VIBES_RPC_MDNS_SERVICE } from "./mdns-discovery.js";
+//# sourceMappingURL=index.js.map

package/dist/fleets/pairing/mdns/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/fleets/pairing/mdns/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAGN,0BAA0B,EAC1B,wBAAwB,EACxB,sBAAsB,EACtB,gBAAgB,EAChB,uBAAuB,EACvB,yBAAyB,EACzB,sBAAsB,EACtB,MAAM,qBAAqB,CAAC"}

package/dist/fleets/pairing/mdns/mdns-discovery.d.ts

@@ -0,0 +1,62 @@
+/**
+ * `fleet/discovery/mdns` — mDNS LAN discovery adapter (fleet.md §4.6).
+ *
+ * Finds LAN runtimes advertising a `_vibes-rpc._tcp` service and registers each
+ * as a `runtime/rpc` **tcp** target. Discovered hosts are evictable (mDNS TTL),
+ * never sticky (fleet.md §10 q1) — unlike a provisioned target.
+ *
+ * STRUCTURE + THE DESCRIPTOR-EMISSION CONTRACT IS THE DELIVERABLE. The real
+ * multicast socket scan is GUARDED behind a capability check and lives behind an
+ * injected {@link MdnsScanner} port — there is no real multicast in CI. The
+ * tested contract is: an advertisement (`MdnsServiceAdvertisement`) → a
+ * schema-valid tcp `runtime/rpc` descriptor, and the adapter shape (id, no
+ * teardown). The default scanner is capability-gated: where mDNS is unavailable
+ * it yields nothing rather than throwing, so the adapter is always safe to run.
+ *
+ * Lifecycle: NONE. The adapter has no `destroy` — it found a host that already
+ * exists on the LAN; it never created it (correction #4).
+ */
+import { type RuntimeRpcDescriptor } from '@vibesdotdev/kernel-rpc';
+import type { FleetDiscoveryAdapter } from '@vibesdotdev/platform/fleets/pairing';
+import { MDNS_DISCOVERY_ADAPTER_ID, VIBES_RPC_MDNS_SERVICE, type MdnsServiceAdvertisement, type MdnsScanner } from './ids.ts';
+export { MDNS_DISCOVERY_ADAPTER_ID, VIBES_RPC_MDNS_SERVICE, type MdnsServiceAdvertisement, type MdnsScanner };
+/**
+ * Stable descriptor id for an advertisement. Namespaced so an mDNS instance
+ * cannot collide with a direct/platform-registered id.
+ */
+export declare function mdnsDescriptorId(ad: MdnsServiceAdvertisement): string;
+/**
+ * Build the tcp `runtime/rpc` descriptor for one advertisement. Validates
+ * against L4a's frozen `RuntimeRpcDescriptorSchema`. No `auth` — LAN discovery
+ * carries no connection credential; the transport relies on the local-network
+ * trust boundary, and L5's per-invoke gates still run on every host-side invoke.
+ */
+export declare function buildMdnsRpcDescriptor(ad: MdnsServiceAdvertisement): RuntimeRpcDescriptor;
+/**
+ * Whether real mDNS multicast is available in this environment. The default
+ * scanner consults this before opening a multicast socket; where it returns
+ * false (CI, workerd, a sandbox with no multicast), the scanner yields nothing
+ * instead of throwing. Overridable for tests.
+ *
+ * The conservative default is `false`: no environment is assumed to have
+ * multicast unless a caller injects a scanner that asserts it. This keeps the
+ * package safe to import and run anywhere — the real LAN scan is opt-in.
+ */
+export declare function mdnsCapabilityAvailable(): boolean;
+/**
+ * The default, capability-gated scanner. With no real multicast available
+ * (the conservative default), it yields nothing — never throws. A production
+ * build that ships a real multicast implementation injects its own
+ * {@link MdnsScanner}; this stub is the safe no-op the adapter degrades to.
+ */
+export declare function createDefaultMdnsScanner(options?: {
+    capability?: () => boolean;
+}): MdnsScanner;
+/**
+ * Create the mDNS LAN discovery adapter. The scanner port defaults to the
+ * capability-gated no-op stub; tests (and a real LAN build) inject one that
+ * yields advertisements. `discover()` maps each advertisement to a tcp
+ * `runtime/rpc` descriptor.
+ */
+export declare function createMdnsDiscoveryAdapter(scanner?: MdnsScanner): FleetDiscoveryAdapter;
+//# sourceMappingURL=mdns-discovery.d.ts.map

package/dist/fleets/pairing/mdns/mdns-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdns-discovery.d.ts","sourceRoot":"","sources":["../../../../src/fleets/pairing/mdns/mdns-discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAEN,KAAK,oBAAoB,EACzB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAClF,OAAO,EACN,yBAAyB,EACzB,sBAAsB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,WAAW,EAChB,MAAM,UAAU,CAAC;AAIlB,OAAO,EACN,yBAAyB,EACzB,sBAAsB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,WAAW,EAChB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,wBAAwB,GAAG,MAAM,CAErE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,wBAAwB,GAAG,oBAAoB,CAmBzF;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,IAAI,OAAO,CAEjD;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACvC,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,OAAO,CAAA;CAAO,GAC1C,WAAW,CAYb;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACzC,OAAO,GAAE,WAAwC,GAC/C,qBAAqB,CAUvB"}

package/dist/fleets/pairing/mdns/mdns-discovery.js

@@ -0,0 +1,108 @@
+/**
+ * `fleet/discovery/mdns` — mDNS LAN discovery adapter (fleet.md §4.6).
+ *
+ * Finds LAN runtimes advertising a `_vibes-rpc._tcp` service and registers each
+ * as a `runtime/rpc` **tcp** target. Discovered hosts are evictable (mDNS TTL),
+ * never sticky (fleet.md §10 q1) — unlike a provisioned target.
+ *
+ * STRUCTURE + THE DESCRIPTOR-EMISSION CONTRACT IS THE DELIVERABLE. The real
+ * multicast socket scan is GUARDED behind a capability check and lives behind an
+ * injected {@link MdnsScanner} port — there is no real multicast in CI. The
+ * tested contract is: an advertisement (`MdnsServiceAdvertisement`) → a
+ * schema-valid tcp `runtime/rpc` descriptor, and the adapter shape (id, no
+ * teardown). The default scanner is capability-gated: where mDNS is unavailable
+ * it yields nothing rather than throwing, so the adapter is always safe to run.
+ *
+ * Lifecycle: NONE. The adapter has no `destroy` — it found a host that already
+ * exists on the LAN; it never created it (correction #4).
+ */
+import { RuntimeRpcDescriptorSchema } from '@vibesdotdev/kernel-rpc';
+import { MDNS_DISCOVERY_ADAPTER_ID, VIBES_RPC_MDNS_SERVICE } from "./ids.js";
+// Re-export the static descriptor identity + port types so the public surface
+// (index.ts and tests) stays centralized in the identity module.
+export { MDNS_DISCOVERY_ADAPTER_ID, VIBES_RPC_MDNS_SERVICE };
+/**
+ * Stable descriptor id for an advertisement. Namespaced so an mDNS instance
+ * cannot collide with a direct/platform-registered id.
+ */
+export function mdnsDescriptorId(ad) {
+    return `mdns:${ad.instanceName}`;
+}
+/**
+ * Build the tcp `runtime/rpc` descriptor for one advertisement. Validates
+ * against L4a's frozen `RuntimeRpcDescriptorSchema`. No `auth` — LAN discovery
+ * carries no connection credential; the transport relies on the local-network
+ * trust boundary, and L5's per-invoke gates still run on every host-side invoke.
+ */
+export function buildMdnsRpcDescriptor(ad) {
+    if (!Number.isInteger(ad.port) || ad.port <= 0 || ad.port > 65535) {
+        throw new Error(`fleet/discovery/mdns: advertisement '${ad.instanceName}' has an invalid port ${ad.port}`);
+    }
+    const descriptor = {
+        id: mdnsDescriptorId(ad),
+        kind: 'runtime/rpc',
+        name: `LAN host ${ad.instanceName}`,
+        description: `Discovered via mDNS (${VIBES_RPC_MDNS_SERVICE}) at ${ad.host}:${ad.port}.`,
+        enabled: true,
+        transport: 'tcp',
+        target: { transport: 'tcp', host: ad.host, port: ad.port }
+    };
+    if (ad.remoteScope)
+        descriptor.remoteScope = ad.remoteScope;
+    const ok = RuntimeRpcDescriptorSchema.safeParse(descriptor);
+    if (!ok.success) {
+        throw new Error(`fleet/discovery/mdns: built an invalid runtime/rpc descriptor: ${ok.error.message}`);
+    }
+    return descriptor;
+}
+/**
+ * Whether real mDNS multicast is available in this environment. The default
+ * scanner consults this before opening a multicast socket; where it returns
+ * false (CI, workerd, a sandbox with no multicast), the scanner yields nothing
+ * instead of throwing. Overridable for tests.
+ *
+ * The conservative default is `false`: no environment is assumed to have
+ * multicast unless a caller injects a scanner that asserts it. This keeps the
+ * package safe to import and run anywhere — the real LAN scan is opt-in.
+ */
+export function mdnsCapabilityAvailable() {
+    return false;
+}
+/**
+ * The default, capability-gated scanner. With no real multicast available
+ * (the conservative default), it yields nothing — never throws. A production
+ * build that ships a real multicast implementation injects its own
+ * {@link MdnsScanner}; this stub is the safe no-op the adapter degrades to.
+ */
+export function createDefaultMdnsScanner(options = {}) {
+    const capable = options.capability ?? mdnsCapabilityAvailable;
+    return {
+        scan(_signal) {
+            capable();
+            return {
+                [Symbol.asyncIterator]() {
+                    return { next: async () => ({ done: true, value: undefined }) };
+                }
+            };
+        }
+    };
+}
+/**
+ * Create the mDNS LAN discovery adapter. The scanner port defaults to the
+ * capability-gated no-op stub; tests (and a real LAN build) inject one that
+ * yields advertisements. `discover()` maps each advertisement to a tcp
+ * `runtime/rpc` descriptor.
+ */
+export function createMdnsDiscoveryAdapter(scanner = createDefaultMdnsScanner()) {
+    return {
+        id: MDNS_DISCOVERY_ADAPTER_ID,
+        async *discover(signal) {
+            for await (const ad of scanner.scan(signal)) {
+                if (signal?.aborted)
+                    return;
+                yield buildMdnsRpcDescriptor(ad);
+            }
+        }
+    };
+}
+//# sourceMappingURL=mdns-discovery.js.map

package/dist/fleets/pairing/mdns/mdns-discovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdns-discovery.js","sourceRoot":"","sources":["../../../../src/fleets/pairing/mdns/mdns-discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EACN,0BAA0B,EAE1B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACN,yBAAyB,EACzB,sBAAsB,EAGtB,MAAM,UAAU,CAAC;AAElB,8EAA8E;AAC9E,iEAAiE;AACjE,OAAO,EACN,yBAAyB,EACzB,sBAAsB,EAGtB,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,EAA4B;IAC5D,OAAO,QAAQ,EAAE,CAAC,YAAY,EAAE,CAAC;AAClC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CAAC,EAA4B;IAClE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,GAAG,KAAK,EAAE,CAAC;QACnE,MAAM,IAAI,KAAK,CAAC,wCAAwC,EAAE,CAAC,YAAY,yBAAyB,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;IAC5G,CAAC;IACD,MAAM,UAAU,GAAyB;QACxC,EAAE,EAAE,gBAAgB,CAAC,EAAE,CAAC;QACxB,IAAI,EAAE,aAAa;QACnB,IAAI,EAAE,YAAY,EAAE,CAAC,YAAY,EAAE;QACnC,WAAW,EAAE,wBAAwB,sBAAsB,QAAQ,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,IAAI,GAAG;QACxF,OAAO,EAAE,IAAI;QACb,SAAS,EAAE,KAAK;QAChB,MAAM,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE;KAC1D,CAAC;IACF,IAAI,EAAE,CAAC,WAAW;QAAE,UAAU,CAAC,WAAW,GAAG,EAAE,CAAC,WAAW,CAAC;IAC5D,MAAM,EAAE,GAAG,0BAA0B,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IAC5D,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,kEAAkE,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;IACvG,CAAC;IACD,OAAO,UAAU,CAAC;AACnB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,uBAAuB;IACtC,OAAO,KAAK,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB,CACvC,UAA0C,EAAE;IAE5C,MAAM,OAAO,GAAG,OAAO,CAAC,UAAU,IAAI,uBAAuB,CAAC;IAC9D,OAAO;QACN,IAAI,CAAC,OAAqB;YACzB,OAAO,EAAE,CAAC;YACV,OAAO;gBACN,CAAC,MAAM,CAAC,aAAa,CAAC;oBACrB,OAAO,EAAE,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC;gBACjE,CAAC;aACD,CAAC;QACH,CAAC;KACD,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,0BAA0B,CACzC,UAAuB,wBAAwB,EAAE;IAEjD,OAAO;QACN,EAAE,EAAE,yBAAyB;QAC7B,KAAK,CAAC,CAAC,QAAQ,CAAC,MAAoB;YACnC,IAAI,KAAK,EAAE,MAAM,EAAE,IAAI,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC7C,IAAI,MAAM,EAAE,OAAO;oBAAE,OAAO;gBAC5B,MAAM,sBAAsB,CAAC,EAAE,CAAC,CAAC;YAClC,CAAC;QACF,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/fleets/pairing/platform/ids.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Static descriptor identity + port types for the platform-pairing discovery
+ * adapter.
+ *
+ * Lives in a separate identity module so callers can use the stable adapter id
+ * and directory port types without importing implementation code.
+ */
+import type { CredentialReference, RuntimeRpcDescriptor } from '@vibesdotdev/kernel-rpc';
+/** Adapter id — the `fleet/discovery` impl key. */
+export declare const PLATFORM_DISCOVERY_ADAPTER_ID = "fleet/discovery/platform";
+/**
+ * One active host as the platform record API reports it (the RESULT of the
+ * pairing handshake — fleet.md §4.6). This is the subset of platform's
+ * `hostSchema`/`daemonSchema` this adapter consumes; it does NOT restate the
+ * full record (platform owns that).
+ */
+export interface PlatformHostRecord {
+    /** Platform `hostSchema.id` — the record id (→ the descriptor id). */
+    readonly hostRecordId: string;
+    /** kebab `hostSchema.hostId` for human routing / the descriptor name. */
+    readonly hostId: string;
+    /**
+     * The host's daemon URL (an https origin) for a DIRECTLY-addressable host —
+     * e.g. a cloud VM with a public IP. Omitted for a NAT'd home machine, which is
+     * reachable only via the relay (`relayBrokerOrigin`). Exactly one of
+     * `daemonOrigin` / `relayBrokerOrigin` must be set.
+     */
+    readonly daemonOrigin?: string;
+    /**
+     * The broker origin a relay-connected host is reachable through (fleet-relay
+     * §3.2). When set, the adapter emits a `transport:'relay'` descriptor routing
+     * through the broker DO at this origin, keyed by `hostId`. This is how a NAT'd
+     * home machine becomes reachable from the cloud (its daemon dials out; the
+     * broker holds the socket).
+     */
+    readonly relayBrokerOrigin?: string;
+    /** The organization that owns this host, when the relay requires its acting scope. */
+    readonly actingOrgId?: string;
+    /**
+     * Reference to the credential used by the consumer-to-runtime connection.
+     * Server consumers provide a secrets/store reference. Signed-in
+     * request hosts use their Auth-owned request-session store for the app JWT. The adapter never resolves or serializes the credential value.
+     */
+    readonly connectionCredential: CredentialReference;
+    /** Optional scope hint the remote advertises (substrate/hardware). */
+    readonly remoteScope?: RuntimeRpcDescriptor['remoteScope'];
+}
+/**
+ * The platform record API port. The adapter asks for active, paired hosts; the
+ * caller injects an impl (a mock in tests, the real platform host record API in
+ * production). This is the seam that keeps the adapter free of any cloud call.
+ *
+ * `pairingCode` is optional: passed, it scopes the lookup to the host a specific
+ * pairing handshake produced; omitted, it lists all currently-active hosts.
+ */
+export interface PlatformHostDirectory {
+    /** Return the active, paired hosts (optionally scoped to one pairing code). */
+    listActiveHosts(pairingCode?: string): Promise<readonly PlatformHostRecord[]>;
+}
+export interface PlatformDiscoveryOptions {
+    /** Scope the lookup to a single pairing handshake's host. */
+    readonly pairingCode?: string;
+}
+//# sourceMappingURL=ids.d.ts.map

package/dist/fleets/pairing/platform/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../../../src/fleets/pairing/platform/ids.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACX,mBAAmB,EACnB,oBAAoB,EACpB,MAAM,yBAAyB,CAAC;AAEjC,mDAAmD;AACnD,eAAO,MAAM,6BAA6B,6BAA6B,CAAC;AAExE;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IAClC,sEAAsE;IACtE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,sFAAsF;IACtF,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,oBAAoB,EAAE,mBAAmB,CAAC;IACnD,sEAAsE;IACtE,QAAQ,CAAC,WAAW,CAAC,EAAE,oBAAoB,CAAC,aAAa,CAAC,CAAC;CAC3D;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,qBAAqB;IACrC,+EAA+E;IAC/E,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,kBAAkB,EAAE,CAAC,CAAC;CAC9E;AAED,MAAM,WAAW,wBAAwB;IACxC,6DAA6D;IAC7D,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC9B"}

package/dist/fleets/pairing/platform/ids.js

@@ -0,0 +1,10 @@
+/**
+ * Static descriptor identity + port types for the platform-pairing discovery
+ * adapter.
+ *
+ * Lives in a separate identity module so callers can use the stable adapter id
+ * and directory port types without importing implementation code.
+ */
+/** Adapter id — the `fleet/discovery` impl key. */
+export const PLATFORM_DISCOVERY_ADAPTER_ID = 'fleet/discovery/platform';
+//# sourceMappingURL=ids.js.map

package/dist/fleets/pairing/platform/ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.js","sourceRoot":"","sources":["../../../../src/fleets/pairing/platform/ids.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,mDAAmD;AACnD,MAAM,CAAC,MAAM,6BAA6B,GAAG,0BAA0B,CAAC"}

package/dist/fleets/pairing/platform/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @vibesdotdev/platform/fleets/pairing/platform — platform-pairing discovery+authz adapter (L6b).
+ *
+ * `fleet/discovery/platform`: platform-known active hosts become `runtime/rpc`
+ * http or relay targets with a per-host `CredentialReference` connection credential. It
+ * consumes the pairing handshake's RESULT (an active host record); it never owns
+ * the handshake, and never resolves the referenced credential to a token (correction #5).
+ */
+export { type PlatformHostRecord, type PlatformHostDirectory, type PlatformDiscoveryOptions, createPlatformDiscoveryAdapter, buildPlatformRpcDescriptor, platformAuthReference, PLATFORM_DISCOVERY_ADAPTER_ID } from './platform-discovery.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/fleets/pairing/platform/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/fleets/pairing/platform/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACN,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,8BAA8B,EAC9B,0BAA0B,EAC1B,qBAAqB,EACrB,6BAA6B,EAC7B,MAAM,yBAAyB,CAAC"}

package/dist/fleets/pairing/platform/index.js

@@ -0,0 +1,10 @@
+/**
+ * @vibesdotdev/platform/fleets/pairing/platform — platform-pairing discovery+authz adapter (L6b).
+ *
+ * `fleet/discovery/platform`: platform-known active hosts become `runtime/rpc`
+ * http or relay targets with a per-host `CredentialReference` connection credential. It
+ * consumes the pairing handshake's RESULT (an active host record); it never owns
+ * the handshake, and never resolves the referenced credential to a token (correction #5).
+ */
+export { createPlatformDiscoveryAdapter, buildPlatformRpcDescriptor, platformAuthReference, PLATFORM_DISCOVERY_ADAPTER_ID } from "./platform-discovery.js";
+//# sourceMappingURL=index.js.map

package/dist/fleets/pairing/platform/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/fleets/pairing/platform/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAIN,8BAA8B,EAC9B,0BAA0B,EAC1B,qBAAqB,EACrB,6BAA6B,EAC7B,MAAM,yBAAyB,CAAC"}