@jskit-ai/console-core 0.1.122 → 0.1.124

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "@jskit-ai/console-core",
-  "version": "0.1.122",
+  "version": "0.1.124",
   "type": "module",
   "scripts": {
     "test": "node --test"
   },
+  "exports": {
+    "./server/ConsoleFeature": "./src/server/ConsoleFeature.js",
+    "./shared/resources/consoleSettingsResource": "./src/shared/resources/consoleSettingsResource.js"
+  },
   "dependencies": {
-    "@jskit-ai/auth-core": "0.1.157",
-    "@jskit-ai/database-runtime": "0.1.159",
-    "@jskit-ai/http-runtime": "0.1.157",
-    "@jskit-ai/kernel": "0.1.159",
-    "@jskit-ai/resource-crud-core": "0.1.101",
-    "@jskit-ai/users-core": "0.1.172",
+    "@jskit-ai/auth-core": "0.1.159",
+    "@jskit-ai/database-runtime": "0.1.161",
+    "@jskit-ai/http-runtime": "0.1.159",
+    "@jskit-ai/kernel": "0.1.161",
+    "@jskit-ai/resource-crud-core": "0.1.103",
+    "@jskit-ai/users-core": "0.1.174",
     "json-rest-schema": "^1.0.17"
   },
   "description": "Console runtime: console settings schema, bootstrap flags, actions, and HTTP routes.",
@@ -19,21 +23,22 @@
     "kind": "runtime",
     "capabilities": {
       "provides": [
-        "console.core",
-        "console.server-routes"
+        "console.core"
       ],
       "requires": [
+        "auth.extensions",
         "runtime.actions",
+        "runtime.bootstrap",
         "runtime.database",
-        "users.core"
+        "runtime.http"
       ]
     },
     "runtime": {
       "server": {
         "providers": [
           {
-            "entrypoint": "src/server/ConsoleCoreServiceProvider.js",
-            "export": "ConsoleCoreServiceProvider"
+            "entrypoint": "src/server/ConsoleFeature.js",
+            "export": "ConsoleFeature"
           }
         ]
       },
@@ -46,9 +51,7 @@
         "tableOwnership": {
           "tables": [
             {
-              "tableName": "console_settings",
-              "provenance": "runtime-package",
-              "ownerKind": "package-runtime"
+              "tableName": "console_settings"
             }
           ]
         }
@@ -57,7 +60,7 @@
         "surfaces": [
           {
             "subpath": "./server",
-            "summary": "Exports ConsoleCoreServiceProvider plus console settings services, routes, and action definitions."
+            "summary": "Exports the explicit Console feature with owner access, settings actions, bootstrap, and routes."
           },
           {
             "subpath": "./shared",
@@ -68,10 +71,9 @@
             "summary": "Exports no runtime API today (reserved client entrypoint)."
           }
         ],
-        "containerTokens": {
-          "server": [],
-          "client": []
-        }
+        "capabilities": [
+          "console.core"
+        ]
       },
       "server": {
         "routes": [
@@ -88,34 +90,10 @@
         ]
       }
     },
-    "mutations": {
-      "dependencies": {
-        "runtime": {
-          "@jskit-ai/auth-core": "0.1.157",
-          "@jskit-ai/database-runtime": "0.1.159",
-          "@jskit-ai/http-runtime": "0.1.157",
-          "@jskit-ai/kernel": "0.1.159",
-          "@jskit-ai/resource-crud-core": "0.1.101",
-          "@jskit-ai/users-core": "0.1.172"
-        },
-        "dev": {}
-      },
-      "packageJson": {
-        "scripts": {}
-      },
-      "procfile": {},
-      "files": [
-        {
-          "op": "install-migration",
-          "from": "templates/migrations/console_core_generic_initial.cjs",
-          "toDir": "migrations",
-          "extension": ".cjs",
-          "reason": "Install console settings schema migration.",
-          "category": "migration",
-          "id": "console-core-generic-initial-schema"
-        }
-      ],
-      "text": []
+    "migrations": {
+      "directories": [
+        "migrations"
+      ]
     }
   }
 }

package/src/server/ConsoleFeature.js

@@ -0,0 +1,67 @@
+import { defineFeature } from "@jskit-ai/kernel/server/features";
+import { createConsoleAuthServiceDecorator } from "./consoleAuthServiceDecorator.js";
+import { createConsoleBootstrapContributor } from "./consoleBootstrapContributor.js";
+import { registerConsoleSettingsRoutes } from "./consoleSettings/bootConsoleSettingsRoutes.js";
+import { buildConsoleSettingsActions } from "./consoleSettings/consoleSettingsActions.js";
+import { createService as createConsoleService } from "./consoleSettings/consoleService.js";
+import { createRepository as createConsoleSettingsRepository } from "./consoleSettings/consoleSettingsRepository.js";
+import { createService as createConsoleSettingsService } from "./consoleSettings/consoleSettingsService.js";
+
+function createConsoleRuntime({ database } = {}) {
+  if (!database || typeof database.knex !== "function") {
+    throw new TypeError("ConsoleFeature requires runtime.database.knex.");
+  }
+
+  const consoleSettingsRepository = createConsoleSettingsRepository(database.knex);
+  const consoleService = createConsoleService({ consoleSettingsRepository });
+  const consoleSettingsService = createConsoleSettingsService({
+    consoleService,
+    consoleSettingsRepository
+  });
+
+  return Object.freeze({
+    repositories: Object.freeze({ settings: consoleSettingsRepository }),
+    services: Object.freeze({
+      access: consoleService,
+      settings: consoleSettingsService
+    })
+  });
+}
+
+const ConsoleFeature = defineFeature({
+  id: "console.core",
+  domain: "console",
+  requires: {
+    authExtensions: "auth.extensions",
+    bootstrap: "runtime.bootstrap",
+    database: "runtime.database",
+    http: "runtime.http"
+  },
+  provides: {
+    console: "console.core"
+  },
+  setup({ authExtensions, bootstrap, database, http }) {
+    const console = createConsoleRuntime({ database });
+
+    authExtensions.registerServiceDecorator(
+      createConsoleAuthServiceDecorator({ consoleService: console.services.access })
+    );
+    bootstrap.register({
+      id: "console.bootstrap",
+      order: 300,
+      contribute: createConsoleBootstrapContributor({
+        consoleService: console.services.access
+      }).contribute
+    });
+    registerConsoleSettingsRoutes(http.router);
+
+    return { console };
+  },
+  actions({ console }) {
+    return buildConsoleSettingsActions({
+      consoleSettingsService: console.services.settings
+    });
+  }
+});
+
+export { ConsoleFeature, createConsoleRuntime };

package/src/server/consoleSettings/bootConsoleSettingsRoutes.js

@@ -5,13 +5,11 @@ function resolveConsoleSettingsRecordId() {
   return "console-settings";
 }
 
-function bootConsoleSettingsRoutes(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("bootConsoleSettingsRoutes requires application make().");
+function registerConsoleSettingsRoutes(router) {
+  if (!router || typeof router.register !== "function") {
+    throw new TypeError("registerConsoleSettingsRoutes requires router.register().");
   }
 
-  const router = app.make("jskit.http.router");
-
   router.register(
     "GET",
     "/api/console/settings",
@@ -68,4 +66,4 @@ function bootConsoleSettingsRoutes(app) {
   );
 }
 
-export { bootConsoleSettingsRoutes };
+export { registerConsoleSettingsRoutes };

package/src/server/consoleSettings/consoleSettingsActions.js

@@ -2,15 +2,16 @@ import {
   emptyInputValidator
 } from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
 import { returnJsonApiData } from "@jskit-ai/http-runtime/shared";
+import { createEntityChangedActionEvent } from "@jskit-ai/kernel/server/actions";
 import { consoleSettingsResource } from "../../shared/resources/consoleSettingsResource.js";
 
-const consoleSettingsActions = Object.freeze([
+const consoleSettingsActionSpecifications = Object.freeze([
   {
     id: "console.settings.read",
     version: 1,
     kind: "query",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "console",
+    surfaces: ["console"],
     permission: {
       require: "authenticated"
     },
@@ -21,8 +22,8 @@ const consoleSettingsActions = Object.freeze([
       actionName: "console.settings.read"
     },
     observability: {},
-    async execute(_input, context, deps) {
-      return returnJsonApiData(await deps.consoleSettingsService.getSettings({
+    async run(consoleSettingsService, _input, context) {
+      return returnJsonApiData(await consoleSettingsService.getSettings({
         context
       }));
     }
@@ -32,7 +33,7 @@ const consoleSettingsActions = Object.freeze([
     version: 1,
     kind: "command",
     channels: ["api", "automation", "internal"],
-    surfacesFrom: "console",
+    surfaces: ["console"],
     permission: {
       require: "authenticated"
     },
@@ -43,12 +44,40 @@ const consoleSettingsActions = Object.freeze([
       actionName: "console.settings.update"
     },
     observability: {},
-    async execute(input, context, deps) {
-      return returnJsonApiData(await deps.consoleSettingsService.updateSettings(input, {
+    extensions: {
+      realtime: {
+        event: "console.settings.changed",
+        audience: "all_users"
+      }
+    },
+    events: [createEntityChangedActionEvent({
+      source: "console",
+      entity: "settings",
+      operation: "updated",
+      entityId: 1,
+      realtime: {
+        event: "console.settings.changed",
+        audience: "all_users"
+      }
+    })],
+    async run(consoleSettingsService, input, context) {
+      return returnJsonApiData(await consoleSettingsService.updateSettings(input, {
         context
       }));
     }
   }
 ]);
 
-export { consoleSettingsActions };
+function buildConsoleSettingsActions({ consoleSettingsService } = {}) {
+  if (!consoleSettingsService) {
+    throw new TypeError("buildConsoleSettingsActions requires consoleSettingsService.");
+  }
+  return consoleSettingsActionSpecifications.map(({ run, ...definition }) => Object.freeze({
+    ...definition,
+    execute(input, context) {
+      return run(consoleSettingsService, input, context);
+    }
+  }));
+}
+
+export { consoleSettingsActionSpecifications, buildConsoleSettingsActions };

package/test/consoleRouteRequestInputValidator.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { ConsoleCoreServiceProvider } from "../src/server/ConsoleCoreServiceProvider.js";
+import { registerConsoleSettingsRoutes } from "../src/server/consoleSettings/bootConsoleSettingsRoutes.js";
 
 function createReplyDouble() {
   return {
@@ -26,9 +26,7 @@ function findRoute(routes, { method, path }) {
   return routes.find((route) => route.method === method && route.path === path) || null;
 }
 
-async function registerRoutes({
-  consoleService = {}
-} = {}) {
+async function registerRoutes() {
   const registeredRoutes = [];
   const router = {
     register(method, path, route, handler) {
@@ -41,27 +39,7 @@ async function registerRoutes({
     }
   };
 
-  const bindings = new Map([
-    ["jskit.http.router", router],
-    ["actionExecutor", {}]
-  ]);
-
-  bindings.set("consoleService", consoleService);
-
-  const app = {
-    has(token) {
-      return bindings.has(token);
-    },
-    make(token) {
-      if (!bindings.has(token)) {
-        throw new Error(`Missing test binding for token: ${String(token)}`);
-      }
-      return bindings.get(token);
-    }
-  };
-
-  const provider = new ConsoleCoreServiceProvider();
-  await provider.boot(app);
+  registerConsoleSettingsRoutes(router);
 
   return registeredRoutes;
 }

package/test/exportsContract.test.js

@@ -12,7 +12,11 @@ test("console-core exports are explicit and aligned with production/template usa
   const result = evaluatePackageExportsContract({
     repoRoot: REPO_ROOT,
     packageDir: PACKAGE_DIR,
-    packageId: "@jskit-ai/console-core"
+    packageId: "@jskit-ai/console-core",
+    requiredExports: [
+      "./server/ConsoleFeature",
+      "./shared/resources/consoleSettingsResource"
+    ]
   });
 
   assert.deepEqual(result.wildcardExports, [], `console-core exports must be explicit. Remove wildcard keys: ${result.wildcardExports.join(", ")}`);

package/test/featureRuntime.test.js

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createAuthExtensions } from "@jskit-ai/auth-core/server/authExtensions";
+import { createActionProvider } from "@jskit-ai/kernel/server/actions";
+import { createCapabilityRuntime, defineProvider } from "@jskit-ai/kernel/shared/capabilities";
+import { createBootstrapRuntime } from "@jskit-ai/kernel/server/runtime";
+import { ConsoleFeature } from "../src/server/ConsoleFeature.js";
+
+test("ConsoleFeature assembles owner access, settings, routes, actions, and bootstrap explicitly", async () => {
+  const routes = [];
+  const authExtensions = createAuthExtensions();
+  const bootstrap = createBootstrapRuntime();
+  let actions = null;
+  let console = null;
+  const probe = defineProvider({
+    id: "test.console.probe",
+    requires: {
+      actionCatalogue: "runtime.actions",
+      consoleCapability: "console.core"
+    },
+    setup({ actionCatalogue, consoleCapability }) {
+      actions = actionCatalogue;
+      console = consoleCapability;
+      return {};
+    }
+  });
+  const runtime = createCapabilityRuntime({
+    inputs: {
+      "auth.extensions": authExtensions,
+      "runtime.bootstrap": bootstrap,
+      "runtime.database": { knex() {} },
+      "runtime.http": {
+        router: {
+          register(method, path) {
+            routes.push(`${method} ${path}`);
+          }
+        }
+      }
+    },
+    providers: [createActionProvider(), ConsoleFeature, probe]
+  });
+
+  await runtime.start();
+
+  assert.equal(typeof console.services.access.requireConsoleOwner, "function");
+  assert.equal(typeof console.services.settings.updateSettings, "function");
+  assert.deepEqual(routes, [
+    "GET /api/console/settings",
+    "PATCH /api/console/settings"
+  ]);
+  assert.deepEqual(
+    actions.listDefinitions().map((definition) => definition.id),
+    ["console.settings.read", "console.settings.update"]
+  );
+  assert.deepEqual(bootstrap.diagnostics().contributorIds, ["console.bootstrap"]);
+  assert.deepEqual(authExtensions.diagnostics().serviceDecoratorIds, [
+    "console.core.authServiceDecorator"
+  ]);
+});

package/src/server/ConsoleCoreServiceProvider.js

@@ -1,22 +0,0 @@
-import { bootConsoleSettingsRoutes } from "./consoleSettings/bootConsoleSettingsRoutes.js";
-import { registerConsoleCore } from "./registerConsoleCore.js";
-import { registerConsoleBootstrap } from "./registerConsoleBootstrap.js";
-import { registerConsoleSettings } from "./consoleSettings/registerConsoleSettings.js";
-
-class ConsoleCoreServiceProvider {
-  static id = "console.core";
-
-  static startsAfter = ["runtime.actions"];
-
-  register(app) {
-    registerConsoleCore(app);
-    registerConsoleBootstrap(app);
-    registerConsoleSettings(app);
-  }
-
-  async boot(app) {
-    bootConsoleSettingsRoutes(app);
-  }
-}
-
-export { ConsoleCoreServiceProvider };

package/src/server/consoleSettings/registerConsoleSettings.js

@@ -1,56 +0,0 @@
-import { withActionDefaults } from "@jskit-ai/kernel/shared/actions";
-import { createService as createConsoleSettingsService } from "./consoleSettingsService.js";
-import { createService as createConsoleService } from "./consoleService.js";
-import { consoleSettingsActions } from "./consoleSettingsActions.js";
-
-function registerConsoleSettings(app) {
-  if (!app || typeof app.singleton !== "function" || typeof app.service !== "function" || typeof app.actions !== "function") {
-    throw new Error("registerConsoleSettings requires application singleton()/service()/actions().");
-  }
-
-  const hasConsoleService = typeof app.has === "function" ? app.has("consoleService") : false;
-  if (!hasConsoleService) {
-    app.singleton("consoleService", (scope) =>
-      createConsoleService({
-        consoleSettingsRepository: scope.make("consoleSettingsRepository")
-      })
-    );
-  }
-
-  app.service(
-    "console.settings.service",
-    (scope) =>
-      createConsoleSettingsService({
-        consoleSettingsRepository: scope.make("consoleSettingsRepository"),
-        consoleService: scope.make("consoleService")
-      }),
-    {
-      events: Object.freeze({
-        updateSettings: Object.freeze([
-          Object.freeze({
-            type: "entity.changed",
-            source: "console",
-            entity: "settings",
-            operation: "updated",
-            entityId: 1,
-            realtime: Object.freeze({
-              event: "console.settings.changed",
-              audience: "all_users"
-            })
-          })
-        ])
-      })
-    }
-  );
-
-  app.actions(
-    withActionDefaults(consoleSettingsActions, {
-      domain: "console",
-      dependencies: {
-        consoleSettingsService: "console.settings.service"
-      }
-    })
-  );
-}
-
-export { registerConsoleSettings };

package/src/server/registerConsoleBootstrap.js

@@ -1,16 +0,0 @@
-import { registerBootstrapPayloadContributor } from "@jskit-ai/kernel/server/runtime";
-import { createConsoleBootstrapContributor } from "./consoleBootstrapContributor.js";
-
-function registerConsoleBootstrap(app) {
-  if (!app || typeof app.singleton !== "function") {
-    throw new Error("registerConsoleBootstrap requires application singleton().");
-  }
-
-  registerBootstrapPayloadContributor(app, "console.core.bootstrap.payloadContributor", (scope) => {
-    return createConsoleBootstrapContributor({
-      consoleService: scope.make("consoleService")
-    });
-  });
-}
-
-export { registerConsoleBootstrap };

package/src/server/registerConsoleCore.js

@@ -1,25 +0,0 @@
-import { registerAuthServiceDecorator } from "@jskit-ai/auth-core/server/authServiceDecoratorRegistry";
-import { createConsoleAuthServiceDecorator } from "./consoleAuthServiceDecorator.js";
-import { createRepository as createConsoleSettingsRepository } from "./consoleSettings/consoleSettingsRepository.js";
-import { registerConsoleCoreActionSurfaceSources } from "./support/consoleActionSurfaces.js";
-
-function registerConsoleCore(app) {
-  if (!app || typeof app.singleton !== "function") {
-    throw new Error("registerConsoleCore requires application singleton().");
-  }
-
-  registerConsoleCoreActionSurfaceSources(app);
-
-  registerAuthServiceDecorator(app, "console.core.authServiceDecorator", (scope) =>
-    createConsoleAuthServiceDecorator({
-      consoleService: scope.make("consoleService")
-    })
-  );
-
-  app.singleton("consoleSettingsRepository", (scope) => {
-    const knex = scope.make("jskit.database.knex");
-    return createConsoleSettingsRepository(knex);
-  });
-}
-
-export { registerConsoleCore };

package/src/server/support/consoleActionSurfaces.js

@@ -1,62 +0,0 @@
-import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
-import { isRecord, normalizeLowerText } from "@jskit-ai/kernel/shared/support/normalize";
-
-const CONSOLE_OWNER_ACCESS_POLICY_ID = "console_owner";
-
-function normalizeSurfaceIds(surfaceIds = []) {
-  const source = Array.isArray(surfaceIds) ? surfaceIds : [];
-  const seen = new Set();
-  const normalized = [];
-
-  for (const candidate of source) {
-    const surfaceId = normalizeSurfaceId(candidate);
-    if (!surfaceId || seen.has(surfaceId)) {
-      continue;
-    }
-    seen.add(surfaceId);
-    normalized.push(surfaceId);
-  }
-
-  return normalized;
-}
-
-function resolveConsoleSurfaceIdsFromAppConfig(appConfig = {}) {
-  const source = isRecord(appConfig?.surfaceDefinitions) ? appConfig.surfaceDefinitions : {};
-  const resolved = [];
-
-  for (const [key, value] of Object.entries(source)) {
-    const definition = isRecord(value) ? value : {};
-    const surfaceId = normalizeSurfaceId(definition.id || key);
-    if (!surfaceId) {
-      continue;
-    }
-    if (definition.enabled === false) {
-      continue;
-    }
-    if (definition.requiresWorkspace === true) {
-      continue;
-    }
-    if (normalizeLowerText(definition.accessPolicyId) !== CONSOLE_OWNER_ACCESS_POLICY_ID) {
-      continue;
-    }
-    resolved.push(surfaceId);
-  }
-
-  return normalizeSurfaceIds(resolved);
-}
-
-function registerConsoleCoreActionSurfaceSources(app) {
-  if (!app || typeof app.actionSurfaceSource !== "function") {
-    return;
-  }
-
-  app.actionSurfaceSource("console", ({ scope }) => {
-    const appConfig = scope?.has?.("appConfig") ? scope.make("appConfig") : {};
-    return resolveConsoleSurfaceIdsFromAppConfig(appConfig);
-  });
-}
-
-export {
-  resolveConsoleSurfaceIdsFromAppConfig,
-  registerConsoleCoreActionSurfaceSources
-};

package/test/bootstrapPayloadIntegration.test.js

@@ -1,78 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createContainer } from "../../kernel/server/container/index.js";
-import { resolveBootstrapPayload } from "../../kernel/server/registries/bootstrapPayloadContributorRegistry.js";
-import { registerUsersBootstrap } from "../../users-core/src/server/registerUsersBootstrap.js";
-import { registerConsoleBootstrap } from "../src/server/registerConsoleBootstrap.js";
-
-function createAuthenticatedProfile(overrides = {}) {
-  return {
-    id: "12",
-    authProvider: "local",
-    authProviderUserSid: "user-12",
-    username: "consoleowner",
-    displayName: "Console Owner",
-    email: "owner@example.com",
-    ...overrides
-  };
-}
-
-test("bootstrap payload preserves consoleowner for authenticated users after users bootstrap runs", async () => {
-  const profile = createAuthenticatedProfile();
-  const app = createContainer();
-
-  app.instance("internal.repository.user-profiles", {
-    async findById(userId) {
-      return String(userId || "") === profile.id ? profile : null;
-    }
-  });
-  app.instance("internal.repository.user-settings", {
-    async ensureForUserId() {
-      return {};
-    }
-  });
-  app.instance("authService", {
-    getOAuthProviderCatalog() {
-      return {
-        providers: [],
-        defaultProvider: null
-      };
-    },
-    writeSessionCookies() {},
-    clearSessionCookies() {}
-  });
-  app.instance("consoleService", {
-    async isConsoleOwnerUserId(userId) {
-      return String(userId || "") === profile.id;
-    }
-  });
-
-  registerConsoleBootstrap(app);
-  registerUsersBootstrap(app);
-
-  const payload = await resolveBootstrapPayload(app, {
-    request: {
-      async executeAction({ actionId }) {
-        assert.equal(actionId, "auth.session.read");
-        return {
-          authenticated: true,
-          actor: {
-            id: profile.id,
-            displayName: profile.displayName,
-            email: profile.email
-          },
-          session: {
-            csrfToken: "csrf-1"
-          }
-        };
-      }
-    },
-    reply: {}
-  });
-
-  assert.equal(payload.session.authenticated, true);
-  assert.equal(payload.session.userId, "12");
-  assert.deepEqual(payload.surfaceAccess, {
-    consoleowner: true
-  });
-});

package/test/consoleActionSurfaces.test.js

@@ -1,24 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  resolveConsoleSurfaceIdsFromAppConfig
-} from "../src/server/support/consoleActionSurfaces.js";
-
-test("resolveConsoleSurfaceIdsFromAppConfig resolves all enabled console-owner surfaces", () => {
-  const surfaceIds = resolveConsoleSurfaceIdsFromAppConfig({
-    surfaceDefinitions: {
-      home: { id: "home", enabled: true, requiresWorkspace: false, accessPolicyId: "public" },
-      console: { id: "console", enabled: true, requiresWorkspace: false, accessPolicyId: "console_owner" },
-      opsConsole: { id: "opsConsole", enabled: true, requiresWorkspace: false, accessPolicyId: "console_owner" },
-      app: { id: "app", enabled: true, requiresWorkspace: true, accessPolicyId: "workspace_member" },
-      disabledConsole: {
-        id: "disabledConsole",
-        enabled: false,
-        requiresWorkspace: false,
-        accessPolicyId: "console_owner"
-      }
-    }
-  });
-
-  assert.deepEqual(surfaceIds, ["console", "opsconsole"]);
-});

package/test/registerConsoleCore.test.js

@@ -1,55 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { registerConsoleCore } from "../src/server/registerConsoleCore.js";
-
-test("registerConsoleCore registers the console action surface alias when action runtime is available", () => {
-  const calls = [];
-  const tags = [];
-  const app = {
-    singleton() {
-      return this;
-    },
-    tag(token, tagName) {
-      tags.push({
-        token: String(token || ""),
-        tagName: String(tagName || "")
-      });
-      return this;
-    },
-    actionSurfaceSource(sourceName, resolver) {
-      calls.push({
-        sourceName: String(sourceName || ""),
-        resolverType: typeof resolver
-      });
-      return this;
-    }
-  };
-
-  registerConsoleCore(app);
-
-  assert.deepEqual(calls, [
-    {
-      sourceName: "console",
-      resolverType: "function"
-    }
-  ]);
-  assert.deepEqual(tags, [
-    {
-      token: "console.core.authServiceDecorator",
-      tagName: "jskit.auth.service.decorators"
-    }
-  ]);
-});
-
-test("registerConsoleCore still works when action runtime has not installed actionSurfaceSource yet", () => {
-  const app = {
-    singleton() {
-      return this;
-    },
-    tag() {
-      return this;
-    }
-  };
-
-  assert.doesNotThrow(() => registerConsoleCore(app));
-});

package/test/registerServiceRealtimeEvents.test.js

@@ -1,38 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { registerConsoleSettings } from "../src/server/consoleSettings/registerConsoleSettings.js";
-
-function createAppDouble() {
-  const serviceCalls = [];
-
-  return {
-    serviceCalls,
-    app: {
-      singleton() {
-        return this;
-      },
-      service(token, factory, metadata) {
-        serviceCalls.push({
-          token,
-          factory,
-          metadata
-        });
-        return this;
-      },
-      actions() {
-        return this;
-      }
-    }
-  };
-}
-
-function findServiceCall(serviceCalls, token) {
-  return serviceCalls.find((entry) => entry.token === token) || null;
-}
-
-test("console settings register publishes console.settings.changed", () => {
-  const payload = createAppDouble();
-  registerConsoleSettings(payload.app);
-  const consoleSettings = findServiceCall(payload.serviceCalls, "console.settings.service");
-  assert.equal(consoleSettings?.metadata?.events?.updateSettings?.[0]?.realtime?.event, "console.settings.changed");
-});