@capybara-hq/kernel 0.1.0-rc.11 → 0.1.0-rc.13

package/dist/{environments/conversation-environments.js → devices/conversation-devices.js}

@@ -13,44 +13,44 @@ import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
 import { isInternalProvider, SandboxProviders } from "../sandbox/providers.js";
-import { environmentNotFound, sandboxUnavailable } from "../sandbox/sandbox.service.js";
-import { EnvironmentAccess } from "./access.js";
-import { EnvironmentsService } from "./environments.service.js";
+import { deviceNotFound, sandboxUnavailable } from "../sandbox/sandbox.service.js";
+import { DeviceAccess } from "./access.js";
+import { DevicesService } from "./devices.service.js";
 /** `details[0].reason` of the error an anonymous IM conversation's sandbox call gets. */
-export const ANONYMOUS_NO_ENVIRONMENT = "anonymous";
-/** Anonymous IM senders have no environment (spec §4.2 item 8): their sandbox tools are off. */
-export const anonymousNoEnvironment = () => new ApiError("sandbox.unavailable", "Anonymous IM senders have no environment, so the sandbox is not available", [{ reason: ANONYMOUS_NO_ENVIRONMENT }]);
+export const ANONYMOUS_NO_DEVICE = "anonymous";
+/** Anonymous IM senders have no device (spec §4.2 item 8): their sandbox tools are off. */
+export const anonymousNoDevice = () => new ApiError("sandbox.unavailable", "Anonymous IM senders have no device, so the sandbox is not available", [{ reason: ANONYMOUS_NO_DEVICE }]);
 /**
- * Which environment a conversation works in (spec 2026-11-07-environments-design §4.1 items 1, 3;
- * §4.2 items 8, 9, 12). A conversation is bound once, to an environment of its owner
+ * Which device a conversation works in (spec 2026-11-07-environments-design §4.1 items 1, 3;
+ * §4.2 items 8, 9, 12). A conversation is bound once, to a device of its owner
  * (`conversations.account_id`): the one chosen at its first send, else the owner's IM default
- * (IM threads), else the owner's default environment. Its sub-agents use the root's. Access is
+ * (IM threads), else the owner's default device. Its sub-agents use the root's. Access is
  * checked when it is bound and again on every sandbox tool call ({@link forTool}); only the owner
- * may use a personal environment, so a conversation never reaches another person's.
+ * may use a personal device, so a conversation never reaches another person's.
  */
-let ConversationEnvironments = class ConversationEnvironments {
+let ConversationDevices = class ConversationDevices {
     db;
     txHost;
     providers;
     access;
-    environments;
-    constructor(db, txHost, providers, access, environments) {
+    devices;
+    constructor(db, txHost, providers, access, devices) {
         this.db = db;
         this.txHost = txHost;
         this.providers = providers;
         this.access = access;
-        this.environments = environments;
+        this.devices = devices;
     }
     /**
-     * The environment a new conversation of `accountId` is bound to: the chosen one when it is
-     * usable by the person (else `environment.not_found` / `environment.unavailable`, and nothing
-     * is created); without a choice the IM default (IM only) or the person's default environment.
+     * The device a new conversation of `accountId` is bound to: the chosen one when it is
+     * usable by the person (else `device.not_found` / `device.unavailable`, and nothing
+     * is created); without a choice the IM default (IM only) or the person's default device.
      * Null (unbound) for anonymous IM senders, and without a cloud sandbox provider when no usable
-     * IM default (a connected machine's environment, say) applies.
+     * IM default (a connected machine's device, say) applies.
      */
     async forNew(orgId, accountId, pick = {}) {
-        if (pick.environmentId !== undefined) {
-            return (await this.access.usable(orgId, accountId, pick.environmentId)).id;
+        if (pick.deviceId !== undefined) {
+            return (await this.access.usable(orgId, accountId, pick.deviceId)).id;
         }
         if (pick.im !== true && this.providers.cloud() === undefined)
             return null;
@@ -59,75 +59,75 @@ let ConversationEnvironments = class ConversationEnvironments {
         return this.defaultFor(orgId, accountId, pick.im === true);
     }
     /**
-     * The environment a sandbox tool call of the conversation tree rooted at `rootConversationId`
+     * The device a sandbox tool call of the conversation tree rooted at `rootConversationId`
      * enters, checked for its owner now. A conversation still unbound (created before
-     * environments, or while no provider existed) is bound first, to the owner's IM default when it
-     * is an IM thread, else to the owner's default environment; a racing call binds it once.
-     * Throws `sandbox.unavailable` for a cloud environment (or none to bind) without a cloud
-     * provider and for an anonymous IM conversation, and `environment.not_found` /
-     * `environment.unavailable` when the owner may not use it now. A conversation bound to a
-     * connected machine's environment (`@device`) does not need a cloud provider.
+     * devices, or while no provider existed) is bound first, to the owner's IM default when it
+     * is an IM thread, else to the owner's default device; a racing call binds it once.
+     * Throws `sandbox.unavailable` for a cloud device (or none to bind) without a cloud
+     * provider and for an anonymous IM conversation, and `device.not_found` /
+     * `device.unavailable` when the owner may not use it now. A conversation bound to a
+     * connected machine's device (`@local`) does not need a cloud provider.
      */
     async forTool(orgId, rootConversationId) {
         const conv = await this.db
             .selectFrom("conversations")
-            .select(["account_id", "environment_id"])
+            .select(["account_id", "device_id"])
             .where("id", "=", rootConversationId)
             .where("org_id", "=", orgId)
             .executeTakeFirst();
         if (!conv)
-            throw environmentNotFound();
+            throw deviceNotFound();
         if (await this.isAnonymous(orgId, conv.account_id))
-            throw anonymousNoEnvironment();
-        let environmentId = conv.environment_id;
-        if (environmentId === null) {
+            throw anonymousNoDevice();
+        let deviceId = conv.device_id;
+        if (deviceId === null) {
             const im = await this.isImThread(rootConversationId);
             const chosen = await this.defaultFor(orgId, conv.account_id, im);
             if (chosen === null)
                 throw sandboxUnavailable();
-            environmentId = await this.bind(rootConversationId, chosen);
+            deviceId = await this.bind(rootConversationId, chosen);
         }
-        if (this.providers.cloud() === undefined && !(await this.isInternal(environmentId))) {
+        if (this.providers.cloud() === undefined && !(await this.isInternal(deviceId))) {
             throw sandboxUnavailable();
         }
-        return (await this.access.usable(orgId, conv.account_id, environmentId)).id;
+        return (await this.access.usable(orgId, conv.account_id, deviceId)).id;
     }
     /**
      * Whether a sandbox tool call of the tree rooted at `rootConversationId` has a provider to run
      * on, for tool listings (ruling R8; no binding, no access check, never throws): a cloud
-     * provider is loaded, or the environment the conversation is bound to (an unbound IM thread:
-     * its owner's IM default) runs on a registered kernel provider (`@device`). A forbidden or gone
-     * environment still counts: the call then says why.
+     * provider is loaded, or the device the conversation is bound to (an unbound IM thread:
+     * its owner's IM default) runs on a registered kernel provider (`@local`). A forbidden or gone
+     * device still counts: the call then says why.
      */
     async usableNow(orgId, rootConversationId) {
         if (this.providers.cloud() !== undefined)
             return true;
         const conv = await this.db
             .selectFrom("conversations")
-            .select(["account_id", "environment_id"])
+            .select(["account_id", "device_id"])
             .where("id", "=", rootConversationId)
             .where("org_id", "=", orgId)
             .executeTakeFirst();
         if (!conv)
             return false;
-        let environmentId = conv.environment_id;
-        if (environmentId === null) {
+        let deviceId = conv.device_id;
+        if (deviceId === null) {
             if (!(await this.isImThread(rootConversationId)))
                 return false;
             const row = await this.db
-                .selectFrom("environment_defaults")
-                .select("environment_id")
+                .selectFrom("device_defaults")
+                .select("device_id")
                 .where("org_id", "=", orgId)
                 .where("account_id", "=", conv.account_id)
                 .executeTakeFirst();
             if (!row)
                 return false;
-            environmentId = row.environment_id;
+            deviceId = row.device_id;
         }
         const env = await this.db
-            .selectFrom("environments")
+            .selectFrom("devices")
             .select("provider")
-            .where("id", "=", environmentId)
+            .where("id", "=", deviceId)
             .executeTakeFirst();
         const provider = env?.provider ?? null;
         return (provider !== null &&
@@ -136,24 +136,24 @@ let ConversationEnvironments = class ConversationEnvironments {
     }
     /**
      * The person's IM default when `im` and it is still theirs, live, in this org and usable (the
-     * table has no such guard), else their default environment (created when missing); null when
+     * table has no such guard), else their default device (created when missing); null when
      * that is needed and there is no cloud provider to make or use it. The owner having left the org
-     * reads as `environment.not_found`.
+     * reads as `device.not_found`.
      */
     async defaultFor(orgId, accountId, im) {
         if (im) {
             const row = await this.db
-                .selectFrom("environment_defaults")
-                .select("environment_id")
+                .selectFrom("device_defaults")
+                .select("device_id")
                 .where("org_id", "=", orgId)
                 .where("account_id", "=", accountId)
                 .executeTakeFirst();
             if (row) {
                 try {
-                    return (await this.access.usable(orgId, accountId, row.environment_id)).id;
+                    return (await this.access.usable(orgId, accountId, row.device_id)).id;
                 }
                 catch (e) {
-                    if (!isEnvironmentGone(e))
+                    if (!isDeviceGone(e))
                         throw e;
                 }
             }
@@ -161,35 +161,35 @@ let ConversationEnvironments = class ConversationEnvironments {
         if (this.providers.cloud() === undefined)
             return null;
         try {
-            return await this.environments.ensureDefault(orgId, accountId);
+            return await this.devices.ensureDefault(orgId, accountId);
         }
         catch (e) {
             if (e instanceof ApiError && e.code === "org.not_found")
-                throw environmentNotFound();
+                throw deviceNotFound();
             throw e;
         }
     }
-    /** Binds an unbound conversation to `environmentId`; returns what it is bound to now. */
-    async bind(conversationId, environmentId) {
+    /** Binds an unbound conversation to `deviceId`; returns what it is bound to now. */
+    async bind(conversationId, deviceId) {
         await this.db
             .updateTable("conversations")
-            .set({ environment_id: environmentId })
+            .set({ device_id: deviceId })
             .where("id", "=", conversationId)
-            .where("environment_id", "is", null)
+            .where("device_id", "is", null)
             .execute();
         const row = await this.db
             .selectFrom("conversations")
-            .select("environment_id")
+            .select("device_id")
             .where("id", "=", conversationId)
             .executeTakeFirstOrThrow();
-        return row.environment_id ?? environmentId;
+        return row.device_id ?? deviceId;
     }
-    /** The environment runs on a kernel-internal provider (`@device`). */
-    async isInternal(environmentId) {
+    /** The device runs on a kernel-internal provider (`@local`). */
+    async isInternal(deviceId) {
         const row = await this.db
-            .selectFrom("environments")
+            .selectFrom("devices")
             .select("provider")
-            .where("id", "=", environmentId)
+            .where("id", "=", deviceId)
             .executeTakeFirst();
         const provider = row?.provider ?? null;
         return provider !== null && isInternalProvider(provider);
@@ -217,15 +217,14 @@ let ConversationEnvironments = class ConversationEnvironments {
 };
 __decorate([
     Transactional()
-], ConversationEnvironments.prototype, "bind", null);
-ConversationEnvironments = __decorate([
+], ConversationDevices.prototype, "bind", null);
+ConversationDevices = __decorate([
     Injectable(),
     __param(0, Inject(KernelDb)),
     __param(1, Inject(TransactionHost)),
     __param(2, Inject(SandboxProviders)),
-    __param(3, Inject(EnvironmentAccess)),
-    __param(4, Inject(EnvironmentsService))
-], ConversationEnvironments);
-export { ConversationEnvironments };
-const isEnvironmentGone = (e) => e instanceof ApiError &&
-    (e.code === "environment.not_found" || e.code === "environment.unavailable");
+    __param(3, Inject(DeviceAccess)),
+    __param(4, Inject(DevicesService))
+], ConversationDevices);
+export { ConversationDevices };
+const isDeviceGone = (e) => e instanceof ApiError && (e.code === "device.not_found" || e.code === "device.unavailable");

package/dist/devices/devices.controller.d.ts

@@ -0,0 +1,36 @@
+import type { z } from "zod";
+import { type Principal } from "../identity/principal.js";
+import { type OrgContext } from "../orgs/org.guard.js";
+import { type DeviceList, DevicesService, type DeviceView } from "./devices.service.js";
+import { type DeviceNameBody, type DeviceParams } from "./dto.js";
+/**
+ * A person's devices in an org (`/api/v1/orgs/:orgId/devices`, spec
+ * 2026-11-07-environments-design §9; `agents.use`, human users only: a service token gets 403).
+ * Phase 1 has personal cloud devices only, each visible to its owner alone: another member
+ * gets 404 `device.not_found`.
+ * - `GET /` → `{ items, defaultId, lastUsedId, cloudAvailable }` (`cloudAvailable`: there is a
+ *   current sandbox provider; ruling R4);
+ * - `POST / { name }` → 201 `{ device }`; `GET /:id`, `PATCH /:id { name }` → `{ device }`;
+ * - `DELETE /:id` → 202 (destroyed by a job after the response);
+ * - `POST /:id/files/reset` → 202 (the reset is enqueued: a worker empties the files, the next use
+ *   starts empty);
+ * - `DELETE /:id/machine` → 204: a local device's machine is disconnected (its credential
+ *   revoked; it must sign in again).
+ */
+export declare class DevicesController {
+    private readonly devices;
+    constructor(devices: DevicesService);
+    list(principal: Principal, org: OrgContext): Promise<DeviceList>;
+    create(principal: Principal, org: OrgContext, body: z.infer<typeof DeviceNameBody>): Promise<{
+        device: DeviceView;
+    }>;
+    get(principal: Principal, org: OrgContext, params: z.infer<typeof DeviceParams>): Promise<{
+        device: DeviceView;
+    }>;
+    rename(principal: Principal, org: OrgContext, params: z.infer<typeof DeviceParams>, body: z.infer<typeof DeviceNameBody>): Promise<{
+        device: DeviceView;
+    }>;
+    remove(principal: Principal, org: OrgContext, params: z.infer<typeof DeviceParams>): Promise<void>;
+    resetFiles(principal: Principal, org: OrgContext, params: z.infer<typeof DeviceParams>): Promise<void>;
+    revokeMachine(principal: Principal, org: OrgContext, params: z.infer<typeof DeviceParams>): Promise<void>;
+}

package/dist/{environments/environments.controller.js → devices/devices.controller.js}

@@ -11,58 +11,58 @@ import { Controller, Delete, Get, HttpCode, Inject, Patch, Post } from "@nestjs/
 import { CurrentPrincipal, patTokenId, requireUser, } from "../identity/principal.js";
 import { ZBody, ZParam } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
-import { EnvironmentCreateBodyDto, EnvironmentParamsDto, EnvironmentRenameBodyDto, } from "./dto.js";
-import { EnvironmentsService, } from "./environments.service.js";
+import { DevicesService } from "./devices.service.js";
+import { DeviceCreateBodyDto, DeviceParamsDto, DeviceRenameBodyDto, } from "./dto.js";
 /**
- * A person's environments in an org (`/api/v1/orgs/:orgId/environments`, spec
+ * A person's devices in an org (`/api/v1/orgs/:orgId/devices`, spec
  * 2026-11-07-environments-design §9; `agents.use`, human users only: a service token gets 403).
- * Phase 1 has personal cloud environments only, each visible to its owner alone: another member
- * gets 404 `environment.not_found`.
+ * Phase 1 has personal cloud devices only, each visible to its owner alone: another member
+ * gets 404 `device.not_found`.
  * - `GET /` → `{ items, defaultId, lastUsedId, cloudAvailable }` (`cloudAvailable`: there is a
  *   current sandbox provider; ruling R4);
- * - `POST / { name }` → 201 `{ environment }`; `GET /:id`, `PATCH /:id { name }` → `{ environment }`;
+ * - `POST / { name }` → 201 `{ device }`; `GET /:id`, `PATCH /:id { name }` → `{ device }`;
  * - `DELETE /:id` → 202 (destroyed by a job after the response);
  * - `POST /:id/files/reset` → 202 (the reset is enqueued: a worker empties the files, the next use
  *   starts empty);
- * - `DELETE /:id/machine` → 204: a device environment's machine is disconnected (its credential
+ * - `DELETE /:id/machine` → 204: a local device's machine is disconnected (its credential
  *   revoked; it must sign in again).
  */
-let EnvironmentsController = class EnvironmentsController {
-    environments;
-    constructor(environments) {
-        this.environments = environments;
+let DevicesController = class DevicesController {
+    devices;
+    constructor(devices) {
+        this.devices = devices;
     }
     async list(principal, org) {
         const p = requireUser(principal);
-        return this.environments.list(org.orgId, p.account.id);
+        return this.devices.list(org.orgId, p.account.id);
     }
     async create(principal, org, body) {
         const p = requireUser(principal);
         return {
-            environment: await this.environments.create(org.orgId, p.account.id, { name: body.name }, patTokenId(p)),
+            device: await this.devices.create(org.orgId, p.account.id, { name: body.name }, patTokenId(p)),
         };
     }
     async get(principal, org, params) {
         const p = requireUser(principal);
-        return { environment: await this.environments.get(org.orgId, p.account.id, params.id) };
+        return { device: await this.devices.get(org.orgId, p.account.id, params.id) };
     }
     async rename(principal, org, params, body) {
         const p = requireUser(principal);
         return {
-            environment: await this.environments.rename(org.orgId, p.account.id, params.id, body.name, patTokenId(p)),
+            device: await this.devices.rename(org.orgId, p.account.id, params.id, body.name, patTokenId(p)),
         };
     }
     async remove(principal, org, params) {
         const p = requireUser(principal);
-        await this.environments.remove(org.orgId, p.account.id, params.id, patTokenId(p));
+        await this.devices.remove(org.orgId, p.account.id, params.id, patTokenId(p));
     }
     async resetFiles(principal, org, params) {
         const p = requireUser(principal);
-        await this.environments.resetFiles(org.orgId, p.account.id, params.id, patTokenId(p));
+        await this.devices.resetFiles(org.orgId, p.account.id, params.id, patTokenId(p));
     }
     async revokeMachine(principal, org, params) {
         const p = requireUser(principal);
-        await this.environments.revokeMachine(org.orgId, p.account.id, params.id, patTokenId(p));
+        await this.devices.revokeMachine(org.orgId, p.account.id, params.id, patTokenId(p));
     }
 };
 __decorate([
@@ -70,55 +70,55 @@ __decorate([
     OrgAction("agents.use"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg())
-], EnvironmentsController.prototype, "list", null);
+], DevicesController.prototype, "list", null);
 __decorate([
     Post(),
     OrgAction("agents.use"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, ZBody(EnvironmentCreateBodyDto))
-], EnvironmentsController.prototype, "create", null);
+    __param(2, ZBody(DeviceCreateBodyDto))
+], DevicesController.prototype, "create", null);
 __decorate([
     Get(":id"),
     OrgAction("agents.use"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, ZParam(EnvironmentParamsDto))
-], EnvironmentsController.prototype, "get", null);
+    __param(2, ZParam(DeviceParamsDto))
+], DevicesController.prototype, "get", null);
 __decorate([
     Patch(":id"),
     OrgAction("agents.use"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, ZParam(EnvironmentParamsDto)),
-    __param(3, ZBody(EnvironmentRenameBodyDto))
-], EnvironmentsController.prototype, "rename", null);
+    __param(2, ZParam(DeviceParamsDto)),
+    __param(3, ZBody(DeviceRenameBodyDto))
+], DevicesController.prototype, "rename", null);
 __decorate([
     Delete(":id"),
     HttpCode(202),
     OrgAction("agents.use"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, ZParam(EnvironmentParamsDto))
-], EnvironmentsController.prototype, "remove", null);
+    __param(2, ZParam(DeviceParamsDto))
+], DevicesController.prototype, "remove", null);
 __decorate([
     Post(":id/files/reset"),
     HttpCode(202),
     OrgAction("agents.use"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, ZParam(EnvironmentParamsDto))
-], EnvironmentsController.prototype, "resetFiles", null);
+    __param(2, ZParam(DeviceParamsDto))
+], DevicesController.prototype, "resetFiles", null);
 __decorate([
     Delete(":id/machine"),
     HttpCode(204),
     OrgAction("agents.use"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, ZParam(EnvironmentParamsDto))
-], EnvironmentsController.prototype, "revokeMachine", null);
-EnvironmentsController = __decorate([
-    Controller("api/v1/orgs/:orgId/environments"),
-    __param(0, Inject(EnvironmentsService))
-], EnvironmentsController);
-export { EnvironmentsController };
+    __param(2, ZParam(DeviceParamsDto))
+], DevicesController.prototype, "revokeMachine", null);
+DevicesController = __decorate([
+    Controller("api/v1/orgs/:orgId/devices"),
+    __param(0, Inject(DevicesService))
+], DevicesController);
+export { DevicesController };

package/dist/devices/devices.module.d.ts

@@ -1,16 +1,8 @@
-import { type OnModuleInit } from "@nestjs/common";
-import { SandboxProviders } from "../sandbox/providers.js";
-import { DeviceSandboxProvider } from "./device-provider.js";
 /**
- * Connected machines (environments spec §6, §13): the caller side of the device relay and the
- * kernel-internal `@device` sandbox provider, registered with {@link SandboxProviders} on init, and
- * the machines and their credentials ({@link MachinesService}).
- * Imported on every role: any replica may run a sandbox operation on a connected environment
- * (the socket itself is held by the gateway role).
+ * Devices (spec 2026-11-07-environments-design): a person's devices
+ * ({@link DevicesService}), who may use one ({@link DeviceAccess}) and the one a
+ * conversation works in ({@link ConversationDevices}). The instances and file systems are the
+ * {@link SandboxModule}'s.
  */
-export declare class DevicesModule implements OnModuleInit {
-    private readonly providers;
-    private readonly device;
-    constructor(providers: SandboxProviders, device: DeviceSandboxProvider);
-    onModuleInit(): void;
+export declare class DevicesModule {
 }

package/dist/devices/devices.module.js

@@ -4,41 +4,28 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { Inject, Module } from "@nestjs/common";
-import { DEVICE_PROVIDER, SandboxProviders } from "../sandbox/providers.js";
+import { Module } from "@nestjs/common";
+import { ExtensionsModule } from "../extensions/extensions.module.js";
+import { LocalDevicesModule } from "../local-devices/local-devices.module.js";
 import { SandboxModule } from "../sandbox/sandbox.module.js";
-import { DeviceSandboxProvider } from "./device-provider.js";
-import { MachinesService } from "./machines.js";
-import { DeviceRelay } from "./relay.js";
-import { DeviceTargets } from "./targets.js";
+import { DeviceAccess } from "./access.js";
+import { ConversationDevices } from "./conversation-devices.js";
+import { DevicesService } from "./devices.service.js";
 /**
- * Connected machines (environments spec §6, §13): the caller side of the device relay and the
- * kernel-internal `@device` sandbox provider, registered with {@link SandboxProviders} on init, and
- * the machines and their credentials ({@link MachinesService}).
- * Imported on every role: any replica may run a sandbox operation on a connected environment
- * (the socket itself is held by the gateway role).
+ * Devices (spec 2026-11-07-environments-design): a person's devices
+ * ({@link DevicesService}), who may use one ({@link DeviceAccess}) and the one a
+ * conversation works in ({@link ConversationDevices}). The instances and file systems are the
+ * {@link SandboxModule}'s.
  */
 let DevicesModule = class DevicesModule {
-    providers;
-    device;
-    constructor(providers, device) {
-        this.providers = providers;
-        this.device = device;
-    }
-    onModuleInit() {
-        this.providers.register({ plugin: DEVICE_PROVIDER, impl: this.device });
-    }
 };
 DevicesModule = __decorate([
     Module({
-        imports: [SandboxModule],
-        providers: [DeviceTargets, DeviceRelay, DeviceSandboxProvider, MachinesService],
-        exports: [DeviceRelay, DeviceSandboxProvider, MachinesService],
-    }),
-    __param(0, Inject(SandboxProviders)),
-    __param(1, Inject(DeviceSandboxProvider))
+        // ExtensionsModule: the provider display names of demoted defaults; LocalDevicesModule: deleting
+        // a local device revokes its machine
+        imports: [SandboxModule, ExtensionsModule, LocalDevicesModule],
+        providers: [DeviceAccess, DevicesService, ConversationDevices],
+        exports: [DeviceAccess, DevicesService, ConversationDevices],
+    })
 ], DevicesModule);
 export { DevicesModule };

package/dist/devices/devices.schemas.d.ts

@@ -0,0 +1,3 @@
+import type { RouteSchemas } from "../platform/route-schemas.js";
+/** The devices routes the Platform operations mirror (`check:platform-ops` keys). */
+export declare const DEVICE_ROUTES: readonly RouteSchemas[];

package/dist/devices/devices.schemas.js

@@ -0,0 +1,14 @@
+import { DeviceNameBody, DeviceParams } from "./dto.js";
+/** The devices routes the Platform operations mirror (`check:platform-ops` keys). */
+export const DEVICE_ROUTES = [
+    { route: "GET /api/v1/orgs/:orgId/devices" },
+    { route: "POST /api/v1/orgs/:orgId/devices", body: DeviceNameBody },
+    { route: "GET /api/v1/orgs/:orgId/devices/:id", params: DeviceParams },
+    {
+        route: "PATCH /api/v1/orgs/:orgId/devices/:id",
+        params: DeviceParams,
+        body: DeviceNameBody,
+    },
+    { route: "DELETE /api/v1/orgs/:orgId/devices/:id", params: DeviceParams },
+    { route: "POST /api/v1/orgs/:orgId/devices/:id/files/reset", params: DeviceParams },
+];