@capybara-hq/kernel 0.1.0-rc.12 → 0.1.0-rc.14

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

@@ -10,8 +10,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { randomUUID } from "node:crypto";
 import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
-import { deviceLeaseKey } from "../devices/keys.js";
-import { MachinesService } from "../devices/machines.js";
 import { ApiError } from "../errors.js";
 import { ExtensionDisplayNames } from "../extensions/display-name.js";
 import { audit } from "../identity/audit.js";
@@ -22,23 +20,25 @@ import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
 import { LockService } from "../infra/lock/lock.service.js";
 import { KERNEL_LOGGER } from "../infra/tokens.js";
+import { deviceLeaseKey } from "../local-devices/keys.js";
+import { MachinesService } from "../local-devices/machines.js";
 import { SandboxJobs } from "../sandbox/jobs.js";
-import { DEVICE_PROVIDER, isInternalProvider, SandboxProviders } from "../sandbox/providers.js";
-import { environmentNotFound, SandboxService } from "../sandbox/sandbox.service.js";
-import { demotedProvider, EnvironmentAccess, environmentProvider, environmentUnavailable, inUseForDefault, } from "./access.js";
+import { isInternalProvider, LOCAL_PROVIDER, SandboxProviders } from "../sandbox/providers.js";
+import { deviceNotFound, SandboxService } from "../sandbox/sandbox.service.js";
+import { DeviceAccess, demotedProvider, deviceProvider, deviceUnavailable, inUseForDefault, } from "./access.js";
 const isUniqueViolation = (e, constraint) => typeof e === "object" &&
     e !== null &&
     e.code === "23505" &&
     e.constraint === constraint;
-const nameTaken = () => new ApiError("environment.name_taken", "You already have an environment with this name");
+const nameTaken = () => new ApiError("device.name_taken", "You already have a device with this name");
 /**
- * Personal environments (spec 2026-11-07-environments-design §4.2 items 7, 12, 13; §6; §9):
+ * Personal devices (spec 2026-11-07-environments-design §4.2 items 7, 12, 13; §6; §9):
  * cloud ones on the deployment's sandbox provider and `device` ones on a connected machine; a
- * person's environments in an org, visible and usable only by their owner (anyone else gets
- * `environment.not_found`). Deleting one soft-deletes it and destroys its instance and files in a
+ * person's devices in an org, visible and usable only by their owner (anyone else gets
+ * `device.not_found`). Deleting one soft-deletes it and destroys its instance and files in a
  * `sandbox-destroy-for` job after the commit.
  */
-let EnvironmentsService = class EnvironmentsService {
+let DevicesService = class DevicesService {
     db;
     txHost;
     config;
@@ -66,8 +66,8 @@ let EnvironmentsService = class EnvironmentsService {
         this.machines = machines;
     }
     /**
-     * The person's live environments in the org, the default first, then by creation. With a
-     * current sandbox provider the default environment is created first if missing (its first need,
+     * The person's live devices in the org, the default first, then by creation. With a
+     * current sandbox provider the default device is created first if missing (its first need,
      * spec §4.2 item 7; an existing one is only read).
      */
     async list(orgId, accountId) {
@@ -76,8 +76,8 @@ let EnvironmentsService = class EnvironmentsService {
         const items = await this.views(orgId, accountId);
         const last = await this.db
             .selectFrom("conversations as c")
-            .innerJoin("environments as e", "e.id", "c.environment_id")
-            .select("c.environment_id")
+            .innerJoin("devices as e", "e.id", "c.device_id")
+            .select("c.device_id")
             .where("c.org_id", "=", orgId)
             .where("c.account_id", "=", accountId)
             .where("e.org_id", "=", orgId)
@@ -90,22 +90,22 @@ let EnvironmentsService = class EnvironmentsService {
         return {
             items,
             defaultId: defaultId ?? items.find((v) => v.isDefault)?.id ?? null,
-            lastUsedId: last?.environment_id ?? null,
+            lastUsedId: last?.device_id ?? null,
             cloudAvailable,
         };
     }
-    /** One of the person's live environments; anyone else's (or a missing one) → `not_found`. */
+    /** One of the person's live devices; anyone else's (or a missing one) → `not_found`. */
     async get(orgId, accountId, id) {
         const [view] = await this.views(orgId, accountId, id);
         if (!view)
-            throw environmentNotFound();
+            throw deviceNotFound();
         return view;
     }
     /**
-     * A new personal cloud environment, ready at once (its instance and files are made on first
-     * use). Needs a current sandbox provider (`environment.unavailable`); a live name of the person's
-     * (case-insensitive) → `environment.name_taken`; `environments.maxPersonal` live ones (the
-     * default counts) → `environment.limit_reached`. Serialized per person by their membership row.
+     * A new personal cloud device, ready at once (its instance and files are made on first
+     * use). Needs a current sandbox provider (`device.unavailable`); a live name of the person's
+     * (case-insensitive) → `device.name_taken`; `devices.maxPersonal` live ones (the
+     * default counts) → `device.limit_reached`. Serialized per person by their membership row.
      */
     async create(orgId, accountId, input, actorTokenId, auditDetail) {
         const id = await this.insert(orgId, accountId, input.name, actorTokenId, auditDetail);
@@ -114,44 +114,44 @@ let EnvironmentsService = class EnvironmentsService {
     async insert(orgId, accountId, name, actorTokenId, auditDetail) {
         const current = this.providers.cloud();
         if (!current)
-            throw environmentUnavailable(null);
+            throw deviceUnavailable(null);
         return this.insertNamed(orgId, accountId, name, "cloud", current.plugin, actorTokenId, auditDetail ?? {});
     }
     /**
-     * A new personal `device` environment for a machine being connected (provider `@device`; the
+     * A new personal local device for a machine being connected (provider `@local`; the
      * machine row is the caller's). Joins the caller's transaction (the device authorization's).
-     * Counted against `environments.maxPersonal` (`environment.limit_reached`); a live name of the
-     * person's → `environment.name_taken`. Needs no cloud provider.
+     * Counted against `devices.maxPersonal` (`device.limit_reached`); a live name of the
+     * person's → `device.name_taken`. Needs no cloud provider.
      */
-    async createDevice(orgId, accountId, name) {
-        const id = await this.insertNamed(orgId, accountId, name, "device", DEVICE_PROVIDER, undefined, {
-            source: "device",
+    async createLocal(orgId, accountId, name) {
+        const id = await this.insertNamed(orgId, accountId, name, "local", LOCAL_PROVIDER, undefined, {
+            source: "local",
         });
         return { id };
     }
     /**
-     * Inserts a named personal environment under the person's membership lock, after the limit
-     * and name checks, and audits `environment.created`. Runs in the caller's transaction.
+     * Inserts a named personal device under the person's membership lock, after the limit
+     * and name checks, and audits `device.created`. Runs in the caller's transaction.
      */
     async insertNamed(orgId, accountId, name, source, provider, actorTokenId, auditDetail) {
         await this.lockMember(orgId, accountId);
         const { n } = await this.db
-            .selectFrom("environments")
+            .selectFrom("devices")
             .select((eb) => eb.fn.countAll().as("n"))
             .where("org_id", "=", orgId)
             .where("owner_kind", "=", "personal")
             .where("owner_account_id", "=", accountId)
             .where("deleted_at", "is", null)
             .executeTakeFirstOrThrow();
-        const max = this.config.get().environments.maxPersonal;
+        const max = this.config.get().devices.maxPersonal;
         if (Number(n) >= max) {
-            throw new ApiError("environment.limit_reached", `You already have ${max} environments in this organization; delete one to create another`);
+            throw new ApiError("device.limit_reached", `You already have ${max} devices in this organization; delete one to create another`);
         }
         await this.assertNameFree(orgId, accountId, name);
         const id = randomUUID();
         try {
             await this.db
-                .insertInto("environments")
+                .insertInto("devices")
                 .values({
                 id,
                 org_id: orgId,
@@ -164,7 +164,7 @@ let EnvironmentsService = class EnvironmentsService {
                 .execute();
         }
         catch (e) {
-            if (isUniqueViolation(e, "environments_name_uq"))
+            if (isUniqueViolation(e, "devices_name_uq"))
                 throw nameTaken();
             throw e;
         }
@@ -172,7 +172,7 @@ let EnvironmentsService = class EnvironmentsService {
             actorAccountId: accountId,
             ...(actorTokenId !== undefined && { actorTokenId }),
             orgId,
-            action: "environment.created",
+            action: "device.created",
             target: id,
             detail: { name, ...auditDetail },
         });
@@ -185,35 +185,35 @@ let EnvironmentsService = class EnvironmentsService {
      */
     async checkCreate(orgId, accountId, name) {
         if (!this.providers.cloud())
-            throw environmentUnavailable(null);
+            throw deviceUnavailable(null);
         const { n } = await this.db
-            .selectFrom("environments")
+            .selectFrom("devices")
             .select((eb) => eb.fn.countAll().as("n"))
             .where("org_id", "=", orgId)
             .where("owner_kind", "=", "personal")
             .where("owner_account_id", "=", accountId)
             .where("deleted_at", "is", null)
             .executeTakeFirstOrThrow();
-        const max = this.config.get().environments.maxPersonal;
+        const max = this.config.get().devices.maxPersonal;
         if (Number(n) >= max) {
-            throw new ApiError("environment.limit_reached", `You already have ${max} environments in this organization; delete one to create another`);
+            throw new ApiError("device.limit_reached", `You already have ${max} devices in this organization; delete one to create another`);
         }
         await this.assertNameFree(orgId, accountId, name);
     }
-    /** How many of the person's conversations work in the environment (read only). */
+    /** How many of the person's conversations work in the device (read only). */
     async boundConversations(orgId, accountId, id) {
         const { n } = await this.db
             .selectFrom("conversations")
             .select((eb) => eb.fn.countAll().as("n"))
             .where("org_id", "=", orgId)
             .where("account_id", "=", accountId)
-            .where("environment_id", "=", id)
+            .where("device_id", "=", id)
             .executeTakeFirstOrThrow();
         return Number(n);
     }
     /**
      * The refusals {@link resetFiles} would raise (not found, its provider not current, a connected
-     * environment), read only.
+     * device), read only.
      */
     async checkReset(orgId, accountId, id) {
         refuseDeviceReset(await this.access.usable(orgId, accountId, id));
@@ -226,7 +226,7 @@ let EnvironmentsService = class EnvironmentsService {
         }
     }
     /**
-     * Renames one of the person's live environments (the default too); see {@link create}. A
+     * Renames one of the person's live devices (the default too); see {@link create}. A
      * renamed former default is the person's own from then on: it loses its demotion mark, so a
      * switch back to its provider no longer restores it.
      */
@@ -238,19 +238,19 @@ let EnvironmentsService = class EnvironmentsService {
         const before = await this.lockOwn(orgId, accountId, id);
         if (before.name === name)
             return;
-        // the same name in another case is this environment's own: the index allows it
+        // the same name in another case is this device's own: the index allows it
         if (before.name?.toLowerCase() !== name.toLowerCase()) {
             await this.assertNameFree(orgId, accountId, name);
         }
         try {
             await this.db
-                .updateTable("environments")
+                .updateTable("devices")
                 .set({ name, demoted_from_provider: null, updated_at: sql `now()` })
                 .where("id", "=", id)
                 .execute();
         }
         catch (e) {
-            if (isUniqueViolation(e, "environments_name_uq"))
+            if (isUniqueViolation(e, "devices_name_uq"))
                 throw nameTaken();
             throw e;
         }
@@ -258,38 +258,38 @@ let EnvironmentsService = class EnvironmentsService {
             actorAccountId: accountId,
             ...(actorTokenId !== undefined && { actorTokenId }),
             orgId,
-            action: "environment.renamed",
+            action: "device.renamed",
             target: id,
             detail: { from: before.name, to: name, ...auditDetail },
         });
     }
     /**
-     * Deletes one of the person's live environments: soft delete, its IM default row cleared, and
+     * Deletes one of the person's live devices: soft delete, its IM default row cleared, and
      * after the commit a `sandbox-destroy-for` job (the worker waits for running commands, then
      * destroys the instance and the files). Conversations bound to it keep pointing at it; their
-     * sandbox tools then fail with `environment.not_found`. A device environment's machine is
+     * sandbox tools then fail with `device.not_found`. A local device's machine is
      * revoked in the same transaction; after the commit it is told `stop { reason: "deleted" }`
      * (while connected) and its connection is closed.
      */
     async remove(orgId, accountId, id, actorTokenId, auditDetail) {
         const before = await this.lockOwn(orgId, accountId, id);
         await this.db
-            .updateTable("environments")
+            .updateTable("devices")
             .set({ deleted_at: sql `now()`, updated_at: sql `now()` })
             .where("id", "=", id)
             .execute();
         await this.db
-            .deleteFrom("environment_defaults")
+            .deleteFrom("device_defaults")
             .where("org_id", "=", orgId)
             .where("account_id", "=", accountId)
-            .where("environment_id", "=", id)
+            .where("device_id", "=", id)
             .execute();
         await this.machines.revokeActive(id, "deleted");
         await audit(this.db.db, {
             actorAccountId: accountId,
             ...(actorTokenId !== undefined && { actorTokenId }),
             orgId,
-            action: "environment.deleted",
+            action: "device.deleted",
             target: id,
             detail: { name: before.name, isDefault: before.is_default, ...auditDetail },
         });
@@ -298,25 +298,25 @@ let EnvironmentsService = class EnvironmentsService {
                 await this.sandboxJobs.destroy([id]);
             }
             catch (err) {
-                // the hourly destruction sweep destroys deleted environments too
-                this.log.warn("cannot schedule environment destruction", { environmentId: id, err });
+                // the hourly destruction sweep destroys deleted devices too
+                this.log.warn("cannot schedule device destruction", { deviceId: id, err });
             }
         });
     }
     /**
-     * Disconnects the machine of one of the person's own device environments (it must sign in
+     * Disconnects the machine of one of the person's own local devices (it must sign in
      * again); see {@link MachinesService.revoke}.
      */
     async revokeMachine(orgId, accountId, id, actorTokenId) {
         await this.machines.revoke(orgId, accountId, id, actorTokenId);
     }
     /**
-     * Starts one of the person's environments over with empty files (after
-     * `environment.files_lost`): records the request (audit), then, after the commit, enqueues the
-     * `sandbox-reset-files` job (deterministic id per environment), whose worker waits for running
+     * Starts one of the person's devices over with empty files (after
+     * `device.files_lost`): records the request (audit), then, after the commit, enqueues the
+     * `sandbox-reset-files` job (deterministic id per device), whose worker waits for running
      * commands and destroys any instance and the file system; the next use creates new ones. Its
-     * provider must be the current one (`environment.unavailable`); a connected environment's files
-     * are its machine owner's (`environment.files_on_device`). An enqueue failure is thrown
+     * provider must be the current one (`device.unavailable`); a local device's files
+     * are its machine owner's (`device.files_on_device`). An enqueue failure is thrown
      * (the request can be repeated: the reset is idempotent).
      */
     async resetFiles(orgId, accountId, id, actorTokenId, auditDetail) {
@@ -330,17 +330,17 @@ let EnvironmentsService = class EnvironmentsService {
             actorAccountId: accountId,
             ...(actorTokenId !== undefined && { actorTokenId }),
             orgId,
-            action: "environment.files_reset",
+            action: "device.files_reset",
             target: id,
             ...(auditDetail !== undefined && { detail: auditDetail }),
         });
     }
     /**
-     * The person's default environment in the org, created when missing (named by the UI, `name`
+     * The person's default device in the org, created when missing (named by the UI, `name`
      * NULL). An existing usable one is read without locking. A live default whose files or
      * instance are kept by a provider that is not the current one (a provider switch, spec §4.2
      * item 13) is stranded: it is demoted (marked with the provider it was demoted from; the UI
-     * names it 「个人环境（<provider display name>）」) and stays listed as unavailable and deletable.
+     * names it 「个人设备（<provider display name>）」) and stays listed as unavailable and deletable.
      * Its replacement is the person's former default demoted from the current provider when there
      * is one (switching back restores it, with its files), else a fresh default. A live default
      * not in use yet (no healthy files, no instance, none being created: {@link inUseForDefault})
@@ -349,7 +349,7 @@ let EnvironmentsService = class EnvironmentsService {
      * belongs to the provider holding its resources once it holds any, else to the one it was
      * demoted from ({@link demotedProvider}), so one swapped out empty and used afterwards is
      * labelled and restored by where its files are.
-     * All of it in one transaction: switching back and forth never adds environments.
+     * All of it in one transaction: switching back and forth never adds devices.
      *
      * Replacing one first takes the person's membership row (`FOR SHARE`, after the org row), so an
      * offboarding that removes them cannot leave a live default behind; not a member (any more) →
@@ -357,8 +357,8 @@ let EnvironmentsService = class EnvironmentsService {
      * defaults of the current provider are locked (`FOR NO KEY UPDATE`) and the live default re-read
      * after them, the partial unique index on the live default makes a racing insert do nothing, and
      * the select that follows reads the winner. Needs a current sandbox provider
-     * (`environment.unavailable`). It is the person's baseline, so it is created even at
-     * `environments.maxPersonal`.
+     * (`device.unavailable`). It is the person's baseline, so it is created even at
+     * `devices.maxPersonal`.
      */
     async ensureDefault(orgId, accountId) {
         const live = await this.defaultOf(orgId, accountId);
@@ -375,7 +375,7 @@ let EnvironmentsService = class EnvironmentsService {
     async insertDefault(orgId, accountId) {
         const current = this.providers.cloud();
         if (!current)
-            throw environmentUnavailable(null);
+            throw deviceUnavailable(null);
         await this.lockMember(orgId, accountId, "share");
         const locked = await this.defaultOf(orgId, accountId, true);
         const former = await this.formerDefaults(orgId, accountId, current.plugin, true);
@@ -391,20 +391,20 @@ let EnvironmentsService = class EnvironmentsService {
         const restore = withFiles ?? (live === undefined || stranded ? former[0] : undefined);
         if (live) {
             const from = stranded
-                ? (environmentProvider(live, current.plugin) ?? "unknown")
+                ? (deviceProvider(live, current.plugin) ?? "unknown")
                 : (live.provider ?? current.plugin);
             await this.demote(live.id, from);
         }
         if (restore) {
             await this.db
-                .updateTable("environments")
+                .updateTable("devices")
                 .set({ is_default: true, demoted_from_provider: null, updated_at: sql `now()` })
                 .where("id", "=", restore.id)
                 .execute();
             return restore.id;
         }
         await this.db
-            .insertInto("environments")
+            .insertInto("devices")
             .values({
             id: randomUUID(),
             org_id: orgId,
@@ -422,17 +422,17 @@ let EnvironmentsService = class EnvironmentsService {
             .execute();
         const row = await this.defaultOf(orgId, accountId);
         if (row === undefined)
-            throw new Error("the default environment was not created");
+            throw new Error("the default device was not created");
         return row.id;
     }
     /**
-     * Turns the live default into an ordinary environment marked as demoted from `provider`; a name
+     * Turns the live default into an ordinary device marked as demoted from `provider`; a name
      * the person gave it stays. Runs under the person's membership lock and the default row's lock,
      * before any other row becomes the default (the partial unique index).
      */
     async demote(id, provider) {
         await this.db
-            .updateTable("environments")
+            .updateTable("devices")
             .set({ is_default: false, demoted_from_provider: provider, updated_at: sql `now()` })
             .where("id", "=", id)
             .execute();
@@ -446,8 +446,8 @@ let EnvironmentsService = class EnvironmentsService {
      */
     async formerDefaults(orgId, accountId, provider, lock = false) {
         const rows = await this.db
-            .selectFrom("environments as e")
-            .leftJoin("environment_instances as i", "i.environment_id", "e.id")
+            .selectFrom("devices as e")
+            .leftJoin("device_instances as i", "i.device_id", "e.id")
             .select([
             "e.id",
             "e.provider",
@@ -491,13 +491,13 @@ let EnvironmentsService = class EnvironmentsService {
             .map(({ r, holdsFiles }) => ({ id: r.id, holdsFiles }));
     }
     /**
-     * The person's IM default (what `/env` set): the environment their next new IM conversation
+     * The person's IM default (what `/device` set): the device their next new IM conversation
      * uses. Null when none was set, or the chosen one is deleted (the row is cleared with it).
      */
     async imDefault(orgId, accountId) {
         const row = await this.db
-            .selectFrom("environment_defaults as d")
-            .innerJoin("environments as e", "e.id", "d.environment_id")
+            .selectFrom("device_defaults as d")
+            .innerJoin("devices as e", "e.id", "d.device_id")
             .select("e.id")
             .where("d.org_id", "=", orgId)
             .where("d.account_id", "=", accountId)
@@ -509,44 +509,44 @@ let EnvironmentsService = class EnvironmentsService {
         return row?.id ?? null;
     }
     /**
-     * Sets the person's IM default. Only one of their own live environments in the org, usable now
-     * (`environment.not_found` / `environment.unavailable` otherwise); the row is written by one
-     * statement that re-checks the environment is live. There is no row lock, so a delete racing
+     * Sets the person's IM default. Only one of their own live devices in the org, usable now
+     * (`device.not_found` / `device.unavailable` otherwise); the row is written by one
+     * statement that re-checks the device is live. There is no row lock, so a delete racing
      * past that check can leave a stale row; reads ignore it ({@link imDefault} joins on
      * `deleted_at IS NULL`).
      */
-    async setImDefault(orgId, accountId, environmentId) {
-        await this.access.usable(orgId, accountId, environmentId);
+    async setImDefault(orgId, accountId, deviceId) {
+        await this.access.usable(orgId, accountId, deviceId);
         const written = await this.db
-            .insertInto("environment_defaults")
-            .columns(["org_id", "account_id", "environment_id"])
+            .insertInto("device_defaults")
+            .columns(["org_id", "account_id", "device_id"])
             .expression(this.db
-            .selectFrom("environments")
+            .selectFrom("devices")
             .select([
             sql `${orgId}::text`.as("org_id"),
             sql `${accountId}::text`.as("account_id"),
             "id",
         ])
-            .where("id", "=", environmentId)
+            .where("id", "=", deviceId)
             .where("org_id", "=", orgId)
             .where("owner_kind", "=", "personal")
             .where("owner_account_id", "=", accountId)
             .where("deleted_at", "is", null))
             .onConflict((oc) => oc
             .columns(["org_id", "account_id"])
-            .doUpdateSet({ environment_id: environmentId, updated_at: new Date() }))
+            .doUpdateSet({ device_id: deviceId, updated_at: new Date() }))
             .executeTakeFirst();
         if (Number(written.numInsertedOrUpdatedRows ?? 0) === 0)
-            throw environmentNotFound();
+            throw deviceNotFound();
     }
     /**
-     * The person's live default environment in the org, if any, with what decides its provider;
+     * The person's live default device in the org, if any, with what decides its provider;
      * `lock` takes its row (`FOR NO KEY UPDATE`; a racing demotion makes it read none).
      */
     async defaultOf(orgId, accountId, lock = false) {
         const row = await this.db
-            .selectFrom("environments as e")
-            .leftJoin("environment_instances as i", "i.environment_id", "e.id")
+            .selectFrom("devices as e")
+            .leftJoin("device_instances as i", "i.device_id", "e.id")
             .select([
             "e.id",
             "e.provider",
@@ -574,15 +574,15 @@ let EnvironmentsService = class EnvironmentsService {
     /** Its files or instance are kept by a provider that is not the current one. */
     stranded(f) {
         const current = this.providers.cloud()?.plugin;
-        return current !== undefined && environmentProvider(f, current) !== current;
+        return current !== undefined && deviceProvider(f, current) !== current;
     }
-    /** The person's live environments (or the one `id`) as views. */
+    /** The person's live devices (or the one `id`) as views. */
     async views(orgId, accountId, id) {
         // all of them even for one `id`: a former default's ordinal counts its siblings
         const all = await this.db
-            .selectFrom("environments as e")
-            .leftJoin("environment_instances as i", "i.environment_id", "e.id")
-            .leftJoin("environment_machines as m", (j) => j.onRef("m.environment_id", "=", "e.id").on("m.revoked_at", "is", null))
+            .selectFrom("devices as e")
+            .leftJoin("device_instances as i", "i.device_id", "e.id")
+            .leftJoin("device_machines as m", (j) => j.onRef("m.device_id", "=", "e.id").on("m.revoked_at", "is", null))
             .select([
             "e.id",
             "e.name",
@@ -641,12 +641,12 @@ let EnvironmentsService = class EnvironmentsService {
             this.displayNames.many(demotedProviders),
         ]);
         const current = this.providers.cloud()?.plugin;
-        // a device environment is online while a replica holds its machine's connection lease
+        // a local device is online while a replica holds its machine's connection lease
         const online = new Map(await Promise.all(rows
-            .filter((r) => r.source === "device")
+            .filter((r) => r.source === "local")
             .map(async (r) => [r.id, (await this.locks.holderOf(deviceLeaseKey(r.id))) !== null])));
         return rows.map((r) => {
-            const provider = environmentProvider(factsOf(r), current);
+            const provider = deviceProvider(factsOf(r), current);
             const live = (r.status === "running" || r.status === "suspended") && r.last_used_at;
             const from = demoted.get(r.id) ?? null;
             return {
@@ -666,7 +666,7 @@ let EnvironmentsService = class EnvironmentsService {
                 available: provider !== null && isInternalProvider(provider)
                     ? this.providers.forName(provider) !== undefined
                     : current !== undefined && provider === current,
-                online: r.source === "device" ? (online.get(r.id) ?? false) : null,
+                online: r.source === "local" ? (online.get(r.id) ?? false) : null,
                 machine: r.machine_id !== null && r.machine_name !== null && r.machine_os !== null
                     ? {
                         id: r.machine_id,
@@ -677,7 +677,7 @@ let EnvironmentsService = class EnvironmentsService {
                         lastSeenAt: r.machine_last_seen_at?.toISOString() ?? null,
                     }
                     : null,
-                // a device environment's machine decides it; cloud environments have none in phase 2
+                // a local device's machine decides it; cloud devices have none in phase 2
                 sessionIsolation: r.machine_session_isolation ?? false,
                 filesLost: r.fs_status === "lost",
                 instance: live
@@ -692,7 +692,7 @@ let EnvironmentsService = class EnvironmentsService {
         });
     }
     /**
-     * Serializes the person's environment writes in the org: the org row (`FOR SHARE`), then their
+     * Serializes the person's device writes in the org: the org row (`FOR SHARE`), then their
      * membership row (`FOR NO KEY UPDATE`, or `FOR SHARE` with `mode` share: enough to keep the
      * membership from being removed meanwhile), the order member removal locks them in. Not a
      * member (any more) → `org.not_found`, as the org guard answers.
@@ -717,11 +717,11 @@ let EnvironmentsService = class EnvironmentsService {
         if (!m)
             throw new ApiError("org.not_found", "Organization not found");
     }
-    /** Locks one of the person's live environments (after their membership); else `not_found`. */
+    /** Locks one of the person's live devices (after their membership); else `not_found`. */
     async lockOwn(orgId, accountId, id) {
         await this.lockMember(orgId, accountId);
         const row = await this.db
-            .selectFrom("environments")
+            .selectFrom("devices")
             .select(["name", "is_default"])
             .where("id", "=", id)
             .where("org_id", "=", orgId)
@@ -731,12 +731,12 @@ let EnvironmentsService = class EnvironmentsService {
             .forNoKeyUpdate()
             .executeTakeFirst();
         if (!row)
-            throw environmentNotFound();
+            throw deviceNotFound();
         return row;
     }
     async assertNameFree(orgId, accountId, name) {
         const clash = await this.db
-            .selectFrom("environments")
+            .selectFrom("devices")
             .select("id")
             .where("org_id", "=", orgId)
             .where("owner_account_id", "=", accountId)
@@ -749,23 +749,23 @@ let EnvironmentsService = class EnvironmentsService {
 };
 __decorate([
     Transactional()
-], EnvironmentsService.prototype, "insert", null);
+], DevicesService.prototype, "insert", null);
 __decorate([
     Transactional()
-], EnvironmentsService.prototype, "createDevice", null);
+], DevicesService.prototype, "createLocal", null);
 __decorate([
     Transactional()
-], EnvironmentsService.prototype, "renameIn", null);
+], DevicesService.prototype, "renameIn", null);
 __decorate([
     Transactional()
-], EnvironmentsService.prototype, "remove", null);
+], DevicesService.prototype, "remove", null);
 __decorate([
     Transactional()
-], EnvironmentsService.prototype, "recordReset", null);
+], DevicesService.prototype, "recordReset", null);
 __decorate([
     Transactional()
-], EnvironmentsService.prototype, "insertDefault", null);
-EnvironmentsService = __decorate([
+], DevicesService.prototype, "insertDefault", null);
+DevicesService = __decorate([
     Injectable(),
     __param(0, Inject(KernelDb)),
     __param(1, Inject(TransactionHost)),
@@ -773,19 +773,19 @@ EnvironmentsService = __decorate([
     __param(3, Inject(SandboxProviders)),
     __param(4, Inject(SandboxService)),
     __param(5, Inject(SandboxJobs)),
-    __param(6, Inject(EnvironmentAccess)),
+    __param(6, Inject(DeviceAccess)),
     __param(7, Inject(ExtensionDisplayNames)),
     __param(8, Inject(KERNEL_LOGGER)),
     __param(9, Inject(LockService)),
     __param(10, Inject(MachinesService))
-], EnvironmentsService);
-export { EnvironmentsService };
+], DevicesService);
+export { DevicesService };
 /**
- * Ruling R24: a connected environment's files are in a directory on its machine, which the
+ * Ruling R24: a local device's files are in a directory on its machine, which the
  * platform never wipes; a lost directory comes back with `capybara-device logout` and a new `login` on the machine.
  */
 function refuseDeviceReset(env) {
-    if (env.provider === DEVICE_PROVIDER) {
-        throw new ApiError("environment.files_on_device", "This environment's files are in a directory on its connected machine and cannot be reset from here. To start over, run capybara-device logout, then capybara-device login into this environment, on that machine.");
+    if (env.provider === LOCAL_PROVIDER) {
+        throw new ApiError("device.files_on_device", "This device's files are in a directory on its connected machine and cannot be reset from here. To start over, run capybara-device logout, then capybara-device login into this device, on that machine.");
     }
 }