@vibesdotdev/host-bun 0.0.0-stage → 1.0.0-rc.2

package/dist/runtime-plugin-host/schemas.d.ts

@@ -0,0 +1,437 @@
+/** The Bun host's hot-plugin importer and runtime-thread declarations. */
+import * as z from 'zod/v4';
+/**
+ * Where generated modules are written, declared by the host: an explicit
+ * `hotDir`, or the host's profile-aware vibes home (`activeHome`, from
+ * `getPathRoots(runtime)`), under which generations are anchored at
+ * `<activeHome>/hot/<key>`. Nothing here reads an ambient runtime.
+ */
+export type BunPluginImporterPlacement = {
+    readonly hotDir: string;
+    readonly activeHome?: undefined;
+} | {
+    readonly activeHome: string;
+    readonly hotDir?: undefined;
+};
+export type BunPluginImporterOptions = BunPluginImporterPlacement & {
+    /** @deprecated Artifacts are retained by invocation custody, never by age. */
+    readonly keepGenerations?: number;
+    /**
+     * The directory Bun's sourcemap `sources` are relative to, from the host's
+     * captured facts (`runtime.localEnvironment.getCwd()`). Optional: an
+     * installed-only importer that never resolves watched sources builds
+     * generations without one; collected sources then fall back to the entry.
+     */
+    readonly cwd?: string;
+    /** Host's immutable package graph receipt, checked again at publication. */
+    readonly artifactIdentity?: () => string | null;
+    /** Diagnostics for the anchor fallback. Optional; defaults to silence. */
+    readonly onNotice?: (message: string, data: HotAnchorNotice) => void;
+};
+export type HotAnchorNotice = {
+    readonly packageRoot: string;
+    readonly activeHome: string;
+    readonly probe: string;
+};
+export declare const RuntimeThreadCompositionSchema: z.ZodReadonly<z.ZodObject<{
+    floor: z.ZodReadonly<z.ZodObject<{
+        plugins: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>>>;
+    }, z.core.$strict>>;
+    global: z.ZodBoolean;
+    globalPlugins: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    omitSurfaces: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        browser: "browser";
+        ssr: "ssr";
+        cli: "cli";
+        tui: "tui";
+        worker: "worker";
+        mcp: "mcp";
+        bridge: "bridge";
+    }>>>>;
+    failurePolicy: z.ZodEnum<{
+        abort: "abort";
+        report: "report";
+    }>;
+    select: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        plugins: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+export declare const RuntimeThreadScopeSchema: z.ZodReadonly<z.ZodObject<{
+    hardware: z.ZodEnum<{
+        consumer: "consumer";
+        cloud: "cloud";
+    }>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodString>;
+        access: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>>;
+    }, z.core.$strict>>;
+    hosting: z.ZodObject<{
+        mode: z.ZodUnion<readonly [z.ZodEnum<{
+            local: "local";
+            hosted: "hosted";
+            "managed-cloud": "managed-cloud";
+        }>, z.ZodString]>;
+        owner: z.ZodUnion<readonly [z.ZodEnum<{
+            consumer: "consumer";
+            customer: "customer";
+            vibes: "vibes";
+        }>, z.ZodString]>;
+        venue: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            "user-device": "user-device";
+            "ipc-worker": "ipc-worker";
+            doks: "doks";
+            "cloudflare-workers": "cloudflare-workers";
+            "digitalocean-functions": "digitalocean-functions";
+        }>, z.ZodString]>>;
+        provider: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    qualifiers: z.ZodObject<{
+        dev: z.ZodBoolean;
+        building: z.ZodOptional<z.ZodBoolean>;
+        environmentTier: z.ZodOptional<z.ZodEnum<{
+            local: "local";
+            dev: "dev";
+            staging: "staging";
+            production: "production";
+        }>>;
+        profile: z.ZodOptional<z.ZodString>;
+        os: z.ZodOptional<z.ZodString>;
+        cef: z.ZodOptional<z.ZodBoolean>;
+        trustedOrigin: z.ZodOptional<z.ZodString>;
+        rendererGeneration: z.ZodOptional<z.ZodNumber>;
+        filesystem: z.ZodOptional<z.ZodString>;
+        browserBackend: z.ZodOptional<z.ZodString>;
+        workspaceSessionId: z.ZodOptional<z.ZodString>;
+        workspaceTarget: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        remoteHostId: z.ZodOptional<z.ZodString>;
+        connectionMode: z.ZodOptional<z.ZodString>;
+        outreachExportsDir: z.ZodOptional<z.ZodString>;
+        serve: z.ZodOptional<z.ZodString>;
+        hotReload: z.ZodOptional<z.ZodEnum<{
+            on: "on";
+            off: "off";
+        }>>;
+        loaderTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        requestPrincipals: z.ZodOptional<z.ZodBoolean>;
+        interactiveSession: z.ZodOptional<z.ZodBoolean>;
+        hostCredentials: z.ZodOptional<z.ZodBoolean>;
+        sharedHost: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    purpose: z.ZodEnum<{
+        agent: "agent";
+        worker: "worker";
+        mcp: "mcp";
+        direct: "direct";
+        projection: "projection";
+    }>;
+    surface: z.ZodEnum<{
+        agent: "agent";
+        browser: "browser";
+        ssr: "ssr";
+        cli: "cli";
+        tui: "tui";
+        worker: "worker";
+        mcp: "mcp";
+        bridge: "bridge";
+    }>;
+    lifecycle: z.ZodEnum<{
+        finite: "finite";
+        persistent: "persistent";
+    }>;
+}, z.core.$strict>>;
+/** What a caller declares for its thread: its role, its own scope and its composition. */
+export declare const RuntimeThreadDeclarationSchema: z.ZodReadonly<z.ZodObject<{
+    role: z.ZodString;
+    scope: z.ZodReadonly<z.ZodObject<{
+        hardware: z.ZodEnum<{
+            consumer: "consumer";
+            cloud: "cloud";
+        }>;
+        workspace: z.ZodOptional<z.ZodObject<{
+            root: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
+        }, z.core.$strict>>;
+        hosting: z.ZodObject<{
+            mode: z.ZodUnion<readonly [z.ZodEnum<{
+                local: "local";
+                hosted: "hosted";
+                "managed-cloud": "managed-cloud";
+            }>, z.ZodString]>;
+            owner: z.ZodUnion<readonly [z.ZodEnum<{
+                consumer: "consumer";
+                customer: "customer";
+                vibes: "vibes";
+            }>, z.ZodString]>;
+            venue: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                "user-device": "user-device";
+                "ipc-worker": "ipc-worker";
+                doks: "doks";
+                "cloudflare-workers": "cloudflare-workers";
+                "digitalocean-functions": "digitalocean-functions";
+            }>, z.ZodString]>>;
+            provider: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        qualifiers: z.ZodObject<{
+            dev: z.ZodBoolean;
+            building: z.ZodOptional<z.ZodBoolean>;
+            environmentTier: z.ZodOptional<z.ZodEnum<{
+                local: "local";
+                dev: "dev";
+                staging: "staging";
+                production: "production";
+            }>>;
+            profile: z.ZodOptional<z.ZodString>;
+            os: z.ZodOptional<z.ZodString>;
+            cef: z.ZodOptional<z.ZodBoolean>;
+            trustedOrigin: z.ZodOptional<z.ZodString>;
+            rendererGeneration: z.ZodOptional<z.ZodNumber>;
+            filesystem: z.ZodOptional<z.ZodString>;
+            browserBackend: z.ZodOptional<z.ZodString>;
+            workspaceSessionId: z.ZodOptional<z.ZodString>;
+            workspaceTarget: z.ZodOptional<z.ZodString>;
+            repositoryId: z.ZodOptional<z.ZodString>;
+            remoteHostId: z.ZodOptional<z.ZodString>;
+            connectionMode: z.ZodOptional<z.ZodString>;
+            outreachExportsDir: z.ZodOptional<z.ZodString>;
+            serve: z.ZodOptional<z.ZodString>;
+            hotReload: z.ZodOptional<z.ZodEnum<{
+                on: "on";
+                off: "off";
+            }>>;
+            loaderTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        capabilities: z.ZodOptional<z.ZodObject<{
+            requestPrincipals: z.ZodOptional<z.ZodBoolean>;
+            interactiveSession: z.ZodOptional<z.ZodBoolean>;
+            hostCredentials: z.ZodOptional<z.ZodBoolean>;
+            sharedHost: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        purpose: z.ZodEnum<{
+            agent: "agent";
+            worker: "worker";
+            mcp: "mcp";
+            direct: "direct";
+            projection: "projection";
+        }>;
+        surface: z.ZodEnum<{
+            agent: "agent";
+            browser: "browser";
+            ssr: "ssr";
+            cli: "cli";
+            tui: "tui";
+            worker: "worker";
+            mcp: "mcp";
+            bridge: "bridge";
+        }>;
+        lifecycle: z.ZodEnum<{
+            finite: "finite";
+            persistent: "persistent";
+        }>;
+    }, z.core.$strict>>;
+    composition: z.ZodReadonly<z.ZodObject<{
+        floor: z.ZodReadonly<z.ZodObject<{
+            plugins: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>>>;
+        }, z.core.$strict>>;
+        global: z.ZodBoolean;
+        globalPlugins: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        omitSurfaces: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            agent: "agent";
+            browser: "browser";
+            ssr: "ssr";
+            cli: "cli";
+            tui: "tui";
+            worker: "worker";
+            mcp: "mcp";
+            bridge: "bridge";
+        }>>>>;
+        failurePolicy: z.ZodEnum<{
+            abort: "abort";
+            report: "report";
+        }>;
+        select: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            plugins: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        root: z.ZodString;
+        cwd: z.ZodString;
+        moduleRoot: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const RuntimeThreadBootSchema: z.ZodReadonly<z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    role: z.ZodString;
+    scope: z.ZodReadonly<z.ZodObject<{
+        hardware: z.ZodEnum<{
+            consumer: "consumer";
+            cloud: "cloud";
+        }>;
+        workspace: z.ZodOptional<z.ZodObject<{
+            root: z.ZodOptional<z.ZodString>;
+            access: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>>;
+        }, z.core.$strict>>;
+        hosting: z.ZodObject<{
+            mode: z.ZodUnion<readonly [z.ZodEnum<{
+                local: "local";
+                hosted: "hosted";
+                "managed-cloud": "managed-cloud";
+            }>, z.ZodString]>;
+            owner: z.ZodUnion<readonly [z.ZodEnum<{
+                consumer: "consumer";
+                customer: "customer";
+                vibes: "vibes";
+            }>, z.ZodString]>;
+            venue: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                "user-device": "user-device";
+                "ipc-worker": "ipc-worker";
+                doks: "doks";
+                "cloudflare-workers": "cloudflare-workers";
+                "digitalocean-functions": "digitalocean-functions";
+            }>, z.ZodString]>>;
+            provider: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        qualifiers: z.ZodObject<{
+            dev: z.ZodBoolean;
+            building: z.ZodOptional<z.ZodBoolean>;
+            environmentTier: z.ZodOptional<z.ZodEnum<{
+                local: "local";
+                dev: "dev";
+                staging: "staging";
+                production: "production";
+            }>>;
+            profile: z.ZodOptional<z.ZodString>;
+            os: z.ZodOptional<z.ZodString>;
+            cef: z.ZodOptional<z.ZodBoolean>;
+            trustedOrigin: z.ZodOptional<z.ZodString>;
+            rendererGeneration: z.ZodOptional<z.ZodNumber>;
+            filesystem: z.ZodOptional<z.ZodString>;
+            browserBackend: z.ZodOptional<z.ZodString>;
+            workspaceSessionId: z.ZodOptional<z.ZodString>;
+            workspaceTarget: z.ZodOptional<z.ZodString>;
+            repositoryId: z.ZodOptional<z.ZodString>;
+            remoteHostId: z.ZodOptional<z.ZodString>;
+            connectionMode: z.ZodOptional<z.ZodString>;
+            outreachExportsDir: z.ZodOptional<z.ZodString>;
+            serve: z.ZodOptional<z.ZodString>;
+            hotReload: z.ZodOptional<z.ZodEnum<{
+                on: "on";
+                off: "off";
+            }>>;
+            loaderTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        capabilities: z.ZodOptional<z.ZodObject<{
+            requestPrincipals: z.ZodOptional<z.ZodBoolean>;
+            interactiveSession: z.ZodOptional<z.ZodBoolean>;
+            hostCredentials: z.ZodOptional<z.ZodBoolean>;
+            sharedHost: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        purpose: z.ZodEnum<{
+            agent: "agent";
+            worker: "worker";
+            mcp: "mcp";
+            direct: "direct";
+            projection: "projection";
+        }>;
+        surface: z.ZodEnum<{
+            agent: "agent";
+            browser: "browser";
+            ssr: "ssr";
+            cli: "cli";
+            tui: "tui";
+            worker: "worker";
+            mcp: "mcp";
+            bridge: "bridge";
+        }>;
+        lifecycle: z.ZodEnum<{
+            finite: "finite";
+            persistent: "persistent";
+        }>;
+    }, z.core.$strict>>;
+    buildSurface: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"public">;
+        evidence: z.ZodLiteral<"baked">;
+        isPublicBinary: z.ZodLiteral<true>;
+        isSourceRun: z.ZodLiteral<false>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"internal">;
+        evidence: z.ZodLiteral<"baked">;
+        isPublicBinary: z.ZodLiteral<false>;
+        isSourceRun: z.ZodLiteral<false>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"source">;
+        evidence: z.ZodLiteral<"unset">;
+        isPublicBinary: z.ZodLiteral<false>;
+        isSourceRun: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+        evidence: z.ZodLiteral<"unrecognized">;
+        isPublicBinary: z.ZodLiteral<false>;
+        isSourceRun: z.ZodLiteral<false>;
+    }, z.core.$strip>], "kind">;
+    host: z.ZodReadonly<z.ZodObject<{
+        root: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        rootCustody: z.ZodOptional<z.ZodBoolean>;
+        shimHref: z.ZodOptional<z.ZodString>;
+        baseEnv: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        selfSpawn: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        selfSpawnSource: z.ZodNullable<z.ZodEnum<{
+            "compiled-binary": "compiled-binary";
+            "bun-source": "bun-source";
+        }>>;
+    }, z.core.$strict>>;
+    paths: z.ZodReadonly<z.ZodObject<{
+        origin: z.ZodEnum<{
+            environment: "environment";
+            "surface-default": "surface-default";
+            "surface-override": "surface-override";
+            "test-isolation": "test-isolation";
+        }>;
+        vibesHome: z.ZodString;
+        configDir: z.ZodString;
+        logDir: z.ZodString;
+        profileName: z.ZodOptional<z.ZodString>;
+        tempDir: z.ZodString;
+    }, z.core.$strict>>;
+    composition: z.ZodReadonly<z.ZodObject<{
+        floor: z.ZodReadonly<z.ZodObject<{
+            plugins: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>>>>;
+        }, z.core.$strict>>;
+        global: z.ZodBoolean;
+        globalPlugins: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        omitSurfaces: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            agent: "agent";
+            browser: "browser";
+            ssr: "ssr";
+            cli: "cli";
+            tui: "tui";
+            worker: "worker";
+            mcp: "mcp";
+            bridge: "bridge";
+        }>>>>;
+        failurePolicy: z.ZodEnum<{
+            abort: "abort";
+            report: "report";
+        }>;
+        select: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+            plugins: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/runtime-plugin-host/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/runtime-plugin-host/schemas.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAO5B;;;;;GAKG;AACH,MAAM,MAAM,0BAA0B,GACnC;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,CAAA;CAAE,GAC5D;IAAE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC;AAEhE,MAAM,MAAM,wBAAwB,GAAG,0BAA0B,GAAG;IACnE,8EAA8E;IAC9E,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IAChD,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,KAAK,IAAI,CAAC;CACrE,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB,CAAC;AAUF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;mBAUrB,CAAC;AAEvB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAA8E,CAAC;AAEpH,0FAA0F;AAC1F,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAKrB,CAAC;AAEvB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsBd,CAAC"}

package/dist/runtime-plugin-host/schemas.js

@@ -0,0 +1,54 @@
+/** The Bun host's hot-plugin importer and runtime-thread declarations. */
+import * as z from 'zod/v4';
+import { BuildSurfaceSchema, RuntimeScopeSchema, RuntimeSurfaceSchema } from '@vibesdotdev/kernel';
+import { OwnedWorkspaceBindingSchema } from '@vibesdotdev/kernel/schemas/bootstrap';
+import { JsonValueSchema } from '@vibesdotdev/kernel/schemas/json';
+import { PluginSpecifierListSchema } from '@vibesdotdev/kernel/schemas/package-plugins';
+import { PathRootsDescriptorSchema } from '@vibesdotdev/paths';
+/**
+ * The Bun host's portable runtime-thread boot (`runtime/plugin-host`
+ * `captureRuntimeThreadBoot` / `spawnRuntimeThread`): immutable host facts,
+ * validated again in the thread before bootstrap or file access. No runtime,
+ * loader, credential or connection crosses it.
+ */
+const ThreadPathRootsSchema = PathRootsDescriptorSchema.unwrap();
+export const RuntimeThreadCompositionSchema = z.object({
+    floor: z.object({
+        plugins: PluginSpecifierListSchema.readonly(),
+        config: z.record(z.string(), z.record(z.string(), JsonValueSchema)).optional()
+    }).strict().readonly(),
+    global: z.boolean(),
+    globalPlugins: PluginSpecifierListSchema.readonly().optional(),
+    omitSurfaces: z.array(RuntimeSurfaceSchema).readonly().optional(),
+    failurePolicy: z.enum(['abort', 'report']),
+    select: z.object({ plugins: PluginSpecifierListSchema.readonly() }).strict().readonly().optional()
+}).strict().readonly();
+export const RuntimeThreadScopeSchema = RuntimeScopeSchema.omit({ actor: true, tenancy: true }).strict().readonly();
+/** What a caller declares for its thread: its role, its own scope and its composition. */
+export const RuntimeThreadDeclarationSchema = z.object({
+    role: z.string().min(1),
+    scope: RuntimeThreadScopeSchema,
+    composition: RuntimeThreadCompositionSchema,
+    workspace: OwnedWorkspaceBindingSchema.optional()
+}).strict().readonly();
+export const RuntimeThreadBootSchema = z.object({
+    version: z.literal(1),
+    role: z.string().min(1),
+    scope: RuntimeThreadScopeSchema,
+    buildSurface: BuildSurfaceSchema,
+    host: z.object({
+        root: ThreadPathRootsSchema.shape.vibesHome,
+        cwd: ThreadPathRootsSchema.shape.vibesHome.optional(),
+        rootCustody: z.boolean().optional(),
+        shimHref: z.string().min(1).optional(),
+        baseEnv: z.record(z.string(), z.string()).readonly().optional(),
+        selfSpawn: z.array(z.string().min(1)).readonly(),
+        selfSpawnSource: z.enum(['compiled-binary', 'bun-source']).nullable()
+    }).strict().refine((host) => (host.selfSpawnSource !== null ? host.selfSpawn.length > 0 : host.rootCustody === true && host.selfSpawn.length === 0), { message: 'Non-owned runtime threads require a non-empty self-spawn argv and source.' }).readonly(),
+    paths: ThreadPathRootsSchema.pick({
+        vibesHome: true, profileName: true, configDir: true,
+        logDir: true, tempDir: true, origin: true
+    }).strict().readonly(),
+    composition: RuntimeThreadCompositionSchema
+}).strict().readonly();
+//# sourceMappingURL=schemas.js.map

package/dist/runtime-plugin-host/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../src/runtime-plugin-host/schemas.ts"],"names":[],"mappings":"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"}

package/dist/runtime-plugin-host/source-watcher.consumer.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Source Watcher
+ *
+ * Watches the source files that were compiled into a tracked plugin's current
+ * generation and reports changes. Sibling of `storage-watcher` and
+ * `config-watcher`: same construct/start/stop/watch/unwatch shape, injected
+ * logger, and no ownership of what a change *means*.
+ *
+ * Directories are watched rather than individual files, because editors and
+ * formatters replace files by atomic rename — a per-file watch goes deaf the
+ * first time a save happens that way. Events for files outside the tracked set
+ * are dropped.
+ *
+ * ## ENOENT re-arm
+ *
+ * A directory can be absent when `watch()` is called, or can be REMOVED and
+ * recreated underneath a live watcher — `bun install` rebuilds a member's
+ * `node_modules` symlink farm exactly this way, `git checkout` of a branch that
+ * does not contain a directory does it, and so does any tool that writes a tree
+ * by "rename the old one away, move the new one in". Both cases used to end the
+ * same way: one `warn` line and a permanently deaf watcher, so HMR silently
+ * stopped reloading and the body drifted while claiming to be hot. Silence is
+ * the worst possible failure mode for a freshness mechanism.
+ *
+ * So a missing directory is not a terminal state. `armMissing` retries on a
+ * bounded interval until the directory exists (or the watch set changes), and a
+ * live watcher that errors is torn down and put back into the same retry queue.
+ * The timer is `unref`'d, so it never holds a process open.
+ *
+ * Platforms disagree on how a replaced directory looks to a live watcher:
+ * macOS FSEvents reports an error, while Linux inotify keeps following the
+ * moved-away inode and only reports a `rename`. So each armed directory
+ * records its identity (device + inode); a `rename` event, `watch()` and
+ * `rearm()` all compare it with the path's current identity, and a missing or
+ * replaced directory is torn down and re-armed like an errored one.
+ *
+ * `fs.watch` can drop a write that lands while the watch is arming. Arm and
+ * rearm stat each tracked file and report a change when its device, inode or
+ * mtime differs from the stamp already recorded. The first observation only
+ * records the stamp.
+ */
+import { type RuntimeRef } from '@vibesdotdev/kernel';
+import type { LoggerInterface } from '@vibesdotdev/kernel/schemas/logger';
+import type { PluginSourceWatcher } from '@vibesdotdev/kernel/reload';
+export interface SourceWatcherOptions {
+    /**
+     * The host runtime: the re-arm retry is its lifecycle interval (RC07), disposed
+     * with the host, and a failed retry loop is logged on it. Poll: a directory
+     * that does not exist yet publishes no "created" event to a watcher of itself.
+     */
+    runtime: RuntimeRef;
+    logger?: LoggerInterface;
+    /** How often to retry a directory that could not be watched. Default 2s. */
+    rearmIntervalMs?: number;
+}
+export declare class SourceWatcher implements PluginSourceWatcher {
+    private readonly watchers;
+    private tracked;
+    private onChange;
+    private readonly log;
+    /** Directories that should be watched but currently are not (ENOENT, EMFILE…). */
+    private readonly pending;
+    /** Last device, inode and mtime stat recorded for a tracked file. */
+    private readonly stamps;
+    private rearmTimer;
+    private readonly rearmIntervalMs;
+    private readonly runtime;
+    constructor(options: SourceWatcherOptions);
+    /** Directories currently waiting to be (re-)armed. Diagnostic. */
+    getPending(): ReadonlySet<string>;
+    /** Try once to arm every pending directory. Exposed so tests need no timer. */
+    rearm(): void;
+    private startRearmTimer;
+    private stopRearmTimer;
+    /** Close one armed watcher and, if the directory is still wanted, queue it for re-arm. */
+    private disarm;
+    /**
+     * Re-arm an armed directory whose path no longer names the directory the
+     * watcher was opened on (removed, or replaced by rename). Returns true when
+     * the existing watcher is still valid.
+     */
+    private verifyArmed;
+    /**
+     * Arm one directory. Returns true when a watcher is now installed; false
+     * leaves the directory in `pending` for the re-arm loop.
+     */
+    private armDirectory;
+    private wantedDirectories;
+    /** Replace the tracked file set. Directories no longer needed are released. */
+    watch(files: readonly string[], onChange: (file: string) => void): void;
+    /** Directories currently held open. */
+    getWatched(): ReadonlySet<string>;
+    /** Files currently eligible to raise a change. */
+    getTracked(): ReadonlySet<string>;
+    unwatchAll(): void;
+    /** Stat one tracked file. A missing path is a null stamp; other stat failures propagate. */
+    private readStamp;
+    private sameStamp;
+    /** Record the stamp `fs.watch` just delivered so a later rearm does not report it again. */
+    private remember;
+    /**
+     * Report tracked files in `directory` whose device, inode or mtime moved
+     * since the stamp on record. The first observation only records the stamp.
+     */
+    private syncTracked;
+    /** Alias matching the sibling watchers' lifecycle vocabulary. */
+    stop(): void;
+}
+//# sourceMappingURL=source-watcher.consumer.d.ts.map

package/dist/runtime-plugin-host/source-watcher.consumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-watcher.consumer.d.ts","sourceRoot":"","sources":["../../src/runtime-plugin-host/source-watcher.consumer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAKH,OAAO,EAAyI,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAsC7L,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,MAAM,WAAW,oBAAoB;IACpC;;;;OAIG;IACH,OAAO,EAAE,UAAU,CAAC;IACpB,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,4EAA4E;IAC5E,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AA0BD,qBAAa,aAAc,YAAW,mBAAmB;IACxD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqC;IAC9D,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,QAAQ,CAAyC;IACzD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;IACtC,kFAAkF;IAClF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,qEAAqE;IACrE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuC;IAC9D,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;gBAEzB,OAAO,EAAE,oBAAoB;IAMzC,kEAAkE;IAClE,UAAU,IAAI,WAAW,CAAC,MAAM,CAAC;IAIjC,+EAA+E;IAC/E,KAAK,IAAI,IAAI;IAcb,OAAO,CAAC,eAAe;IAKvB,OAAO,CAAC,cAAc;IAMtB,0FAA0F;IAC1F,OAAO,CAAC,MAAM;IAWd;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAoBnB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAiDpB,OAAO,CAAC,iBAAiB;IAIzB,+EAA+E;IAC/E,KAAK,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAgCvE,uCAAuC;IACvC,UAAU,IAAI,WAAW,CAAC,MAAM,CAAC;IAIjC,kDAAkD;IAClD,UAAU,IAAI,WAAW,CAAC,MAAM,CAAC;IAQjC,UAAU,IAAI,IAAI;IAUlB,4FAA4F;IAC5F,OAAO,CAAC,SAAS;IAWjB,OAAO,CAAC,SAAS;IAKjB,4FAA4F;IAC5F,OAAO,CAAC,QAAQ;IAWhB;;;OAGG;IACH,OAAO,CAAC,WAAW;IAwBnB,iEAAiE;IACjE,IAAI,IAAI,IAAI;CAGZ"}