@jskit-ai/console-core 0.1.17 → 0.1.19

package/package.descriptor.mjs

@@ -1,12 +1,14 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/console-core",
-  version: "0.1.17",
+  version: "0.1.19",
   kind: "runtime",
   description: "Console runtime: console settings schema, bootstrap flags, actions, and HTTP routes.",
   dependsOn: [
+    "@jskit-ai/auth-core",
     "@jskit-ai/database-runtime",
     "@jskit-ai/http-runtime",
+    "@jskit-ai/resource-crud-core",
     "@jskit-ai/users-core"
   ],
   capabilities: {
@@ -42,7 +44,7 @@ export default Object.freeze({
         },
         {
           subpath: "./shared",
-          summary: "Exports shared console settings resource and field registration helpers."
+          summary: "Exports the shared console settings resource contract."
         },
         {
           subpath: "./client",
@@ -72,11 +74,12 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/database-runtime": "0.1.54",
-        "@jskit-ai/http-runtime": "0.1.53",
-        "@jskit-ai/kernel": "0.1.54",
-        "@jskit-ai/users-core": "0.1.64",
-        "typebox": "^1.0.81"
+        "@jskit-ai/auth-core": "0.1.55",
+        "@jskit-ai/database-runtime": "0.1.56",
+        "@jskit-ai/http-runtime": "0.1.55",
+        "@jskit-ai/kernel": "0.1.56",
+        "@jskit-ai/resource-crud-core": "0.1.1",
+        "@jskit-ai/users-core": "0.1.66"
       },
       dev: {}
     },
@@ -93,27 +96,9 @@ export default Object.freeze({
         reason: "Install console settings schema migration.",
         category: "migration",
         id: "console-core-generic-initial-schema"
-      },
-      {
-        from: "templates/packages/main/src/shared/resources/consoleSettingsFields.js",
-        to: "packages/main/src/shared/resources/consoleSettingsFields.js",
-        preserveOnRemove: true,
-        reason: "Install app-owned console settings field definitions.",
-        category: "console-core",
-        id: "console-core-app-owned-console-settings-fields"
       }
     ],
     text: [
-      {
-        op: "append-text",
-        file: "packages/main/src/shared/index.js",
-        position: "top",
-        skipIfContains: "import \"./resources/consoleSettingsFields.js\";",
-        value: "import \"./resources/consoleSettingsFields.js\";\n",
-        reason: "Load app-owned console settings field definitions inside the main shared module.",
-        category: "console-core",
-        id: "console-core-main-shared-console-settings-field-import"
-      }
     ]
   }
 });

package/package.json

@@ -1,18 +1,17 @@
 {
   "name": "@jskit-ai/console-core",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "type": "module",
   "scripts": {
     "test": "node --test"
   },
-  "exports": {
-    "./shared/resources/consoleSettingsFields": "./src/shared/resources/consoleSettingsFields.js"
-  },
   "dependencies": {
-    "@jskit-ai/database-runtime": "0.1.54",
-    "@jskit-ai/http-runtime": "0.1.53",
-    "@jskit-ai/kernel": "0.1.54",
-    "@jskit-ai/users-core": "0.1.64",
-    "typebox": "^1.0.81"
+    "@jskit-ai/auth-core": "0.1.55",
+    "@jskit-ai/database-runtime": "0.1.56",
+    "@jskit-ai/http-runtime": "0.1.55",
+    "@jskit-ai/kernel": "0.1.56",
+    "@jskit-ai/resource-crud-core": "0.1.1",
+    "@jskit-ai/users-core": "0.1.66",
+    "json-rest-schema": "1.x.x"
   }
 }

package/src/server/consoleAuthServiceDecorator.js

@@ -0,0 +1,80 @@
+import { AUTH_PATHS } from "@jskit-ai/auth-core/shared/authPaths";
+import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
+
+function normalizeRequestPathname(request = null) {
+  const candidates = [
+    request?.routeOptions?.url,
+    request?.routerPath,
+    request?.url,
+    request?.raw?.url
+  ];
+
+  for (const candidate of candidates) {
+    const raw = String(candidate || "").trim();
+    if (!raw) {
+      continue;
+    }
+    const withoutQuery = raw.split("?")[0];
+    const pathname = withoutQuery.split("#")[0];
+    if (pathname) {
+      return pathname;
+    }
+  }
+
+  return "";
+}
+
+function createConsoleAuthServiceDecorator({ consoleService } = {}) {
+  if (!consoleService || typeof consoleService.ensureInitialConsoleMember !== "function") {
+    throw new Error("createConsoleAuthServiceDecorator requires consoleService.ensureInitialConsoleMember().");
+  }
+
+  let consoleOwnerInitialized = false;
+
+  return Object.freeze({
+    decoratorId: "console.core.authServiceDecorator",
+    order: 0,
+    decorateAuthService(authService) {
+      if (!authService || typeof authService.authenticateRequest !== "function") {
+        return authService;
+      }
+
+      return Object.freeze(
+        Object.assign(Object.create(authService), {
+          async authenticateRequest(request, ...args) {
+            const authResult = await authService.authenticateRequest(request, ...args);
+            if (consoleOwnerInitialized) {
+              return authResult;
+            }
+
+            const requestPathname = normalizeRequestPathname(request);
+            if (requestPathname !== AUTH_PATHS.SESSION) {
+              return authResult;
+            }
+
+            const authenticatedUserId =
+              authResult?.authenticated === true
+                ? normalizeRecordId(authResult?.profile?.id, { fallback: null })
+                : null;
+
+            if (!authenticatedUserId) {
+              return authResult;
+            }
+
+            const ownerUserId = normalizeRecordId(
+              await consoleService.ensureInitialConsoleMember(authenticatedUserId),
+              { fallback: null }
+            );
+            if (ownerUserId) {
+              consoleOwnerInitialized = true;
+            }
+
+            return authResult;
+          }
+        })
+      );
+    }
+  });
+}
+
+export { createConsoleAuthServiceDecorator };

package/src/server/consoleBootstrapContributor.js

@@ -1,8 +1,8 @@
 import { normalizeObject, normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 
 function createConsoleBootstrapContributor({ consoleService } = {}) {
-  if (!consoleService || typeof consoleService.ensureInitialConsoleMember !== "function") {
-    throw new Error("createConsoleBootstrapContributor requires consoleService.ensureInitialConsoleMember().");
+  if (!consoleService || typeof consoleService.isConsoleOwnerUserId !== "function") {
+    throw new Error("createConsoleBootstrapContributor requires consoleService.isConsoleOwnerUserId().");
   }
 
   return Object.freeze({
@@ -17,11 +17,7 @@ function createConsoleBootstrapContributor({ consoleService } = {}) {
 
       let consoleOwner = false;
       if (authenticatedUserId) {
-        const seededConsoleOwnerUserId = normalizeRecordId(
-          await consoleService.ensureInitialConsoleMember(authenticatedUserId),
-          { fallback: null }
-        );
-        consoleOwner = Boolean(seededConsoleOwnerUserId) && seededConsoleOwnerUserId === authenticatedUserId;
+        consoleOwner = await consoleService.isConsoleOwnerUserId(authenticatedUserId);
       }
 
       return {

package/src/server/consoleSettings/bootConsoleSettingsRoutes.js

@@ -18,8 +18,8 @@ function bootConsoleSettingsRoutes(app) {
         tags: ["console", "settings"],
         summary: "Get console settings"
       },
-      responseValidators: withStandardErrorResponses({
-        200: consoleSettingsResource.operations.view.outputValidator
+      responses: withStandardErrorResponses({
+        200: consoleSettingsResource.operations.view.output
       })
     },
     async function (request, reply) {
@@ -40,10 +40,10 @@ function bootConsoleSettingsRoutes(app) {
         tags: ["console", "settings"],
         summary: "Update console settings"
       },
-      bodyValidator: consoleSettingsResource.operations.replace.bodyValidator,
-      responseValidators: withStandardErrorResponses(
+      body: consoleSettingsResource.operations.replace.body,
+      responses: withStandardErrorResponses(
         {
-          200: consoleSettingsResource.operations.view.outputValidator
+          200: consoleSettingsResource.operations.view.output
         },
         { includeValidation400: true }
       )
@@ -51,9 +51,7 @@ function bootConsoleSettingsRoutes(app) {
     async function (request, reply) {
       const response = await request.executeAction({
         actionId: "console.settings.update",
-        input: {
-          payload: request.input.body
-        }
+        input: request.input.body
       });
       reply.code(200).send(response);
     }

package/src/server/consoleSettings/consoleService.js

@@ -5,6 +5,9 @@ function createService({ consoleSettingsRepository } = {}) {
   if (!consoleSettingsRepository || typeof consoleSettingsRepository.ensureOwnerUserId !== "function") {
     throw new Error("consoleService requires consoleSettingsRepository.ensureOwnerUserId().");
   }
+  if (!consoleSettingsRepository || typeof consoleSettingsRepository.getSingleton !== "function") {
+    throw new Error("consoleService requires consoleSettingsRepository.getSingleton().");
+  }
 
   async function ensureInitialConsoleMember(userId, options = {}) {
     const normalizedUserId = normalizeRecordId(userId, { fallback: null });
@@ -15,6 +18,17 @@ function createService({ consoleSettingsRepository } = {}) {
     return consoleSettingsRepository.ensureOwnerUserId(normalizedUserId, options);
   }
 
+  async function isConsoleOwnerUserId(userId, options = {}) {
+    const normalizedUserId = normalizeRecordId(userId, { fallback: null });
+    if (!normalizedUserId) {
+      return false;
+    }
+
+    const settings = await consoleSettingsRepository.getSingleton(options);
+    const ownerUserId = normalizeRecordId(settings?.ownerUserId, { fallback: null });
+    return Boolean(ownerUserId) && ownerUserId === normalizedUserId;
+  }
+
   async function requireConsoleOwner(context = {}, options = {}) {
     const actorUserId = normalizeRecordId(context?.actor?.id, { fallback: null });
     if (!actorUserId) {
@@ -29,6 +43,7 @@ function createService({ consoleSettingsRepository } = {}) {
 
   return Object.freeze({
     ensureInitialConsoleMember,
+    isConsoleOwnerUserId,
     requireConsoleOwner
   });
 }

package/src/server/consoleSettings/consoleSettingsActions.js

@@ -1,5 +1,5 @@
 import {
-  EMPTY_INPUT_VALIDATOR
+  emptyInputValidator
 } from "@jskit-ai/kernel/shared/actions/actionContributorHelpers";
 import { consoleSettingsResource } from "../../shared/resources/consoleSettingsResource.js";
 
@@ -13,8 +13,8 @@ const consoleSettingsActions = Object.freeze([
     permission: {
       require: "authenticated"
     },
-    inputValidator: EMPTY_INPUT_VALIDATOR,
-    outputValidator: consoleSettingsResource.operations.view.outputValidator,
+    input: emptyInputValidator,
+    output: consoleSettingsResource.operations.view.output,
     idempotency: "none",
     audit: {
       actionName: "console.settings.read"
@@ -35,17 +35,15 @@ const consoleSettingsActions = Object.freeze([
     permission: {
       require: "authenticated"
     },
-    inputValidator: {
-      payload: consoleSettingsResource.operations.replace.bodyValidator
-    },
-    outputValidator: consoleSettingsResource.operations.replace.outputValidator,
+    input: consoleSettingsResource.operations.replace.body,
+    output: consoleSettingsResource.operations.replace.output,
     idempotency: "optional",
     audit: {
       actionName: "console.settings.update"
     },
     observability: {},
     async execute(input, context, deps) {
-      return deps.consoleSettingsService.updateSettings(input.payload, {
+      return deps.consoleSettingsService.updateSettings(input, {
         context
       });
     }

package/src/server/consoleSettings/consoleSettingsRepository.js

@@ -4,30 +4,12 @@ import {
   createWithTransaction
 } from "@jskit-ai/database-runtime/shared";
 import { toInsertDateTime } from "@jskit-ai/database-runtime/shared";
-import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators/inputNormalization";
 import { normalizeRecordId as normalizeKernelRecordId } from "@jskit-ai/kernel/shared/support/normalize";
-import { consoleSettingsFields } from "../../shared/resources/consoleSettingsFields.js";
 
 function nowDb() {
   return toInsertDateTime();
 }
 
-function mapSettings(row = {}) {
-  const settings = {};
-  for (const field of consoleSettingsFields) {
-    const repositoryColumn = field?.repository?.column;
-    const rawValue = Object.hasOwn(row, repositoryColumn)
-      ? row[repositoryColumn]
-      : field.resolveDefault({
-          settings: row
-        });
-    settings[field.key] = field.normalizeOutput(rawValue, {
-      settings: row
-    });
-  }
-  return settings;
-}
-
 function mapSingletonRow(row) {
   if (!row) {
     throw new Error("console_settings singleton row is missing.");
@@ -37,7 +19,7 @@ function mapSingletonRow(row) {
   return {
     id: normalizeDbRecordId(row.id, { fallback: "1" }),
     ownerUserId,
-    settings: mapSettings(row),
+    settings: {},
     createdAt: toIsoString(row.created_at),
     updatedAt: toIsoString(row.updated_at)
   };
@@ -88,20 +70,10 @@ function createRepository(knex) {
 
   async function updateSingleton(patch, options = {}) {
     const client = options?.trx || knex;
-    const source = normalizeObjectInput(patch);
     const dbPatch = {
       updated_at: nowDb()
     };
 
-    for (const field of consoleSettingsFields) {
-      if (!Object.hasOwn(source, field.key)) {
-        continue;
-      }
-      dbPatch[field.repository.column] = field.normalizeInput(source[field.key], {
-        payload: source
-      });
-    }
-
     await client("console_settings")
       .where({ id: 1 })
       .update(dbPatch);

package/src/server/registerConsoleCore.js

@@ -1,3 +1,5 @@
+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";
 
@@ -8,6 +10,12 @@ function registerConsoleCore(app) {
 
   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);

package/src/shared/resources/consoleSettingsResource.js

@@ -1,119 +1,24 @@
-import { Type } from "typebox";
+import { createSchema } from "json-rest-schema";
+import { defineCrudResource } from "@jskit-ai/resource-crud-core/shared/crudResource";
 import { createOperationMessages } from "../operationMessages.js";
-import {
-  createCursorListValidator,
-  normalizeObjectInput,
-  normalizeSettingsFieldInput,
-  normalizeSettingsFieldOutput
-} from "@jskit-ai/kernel/shared/validators";
-import { consoleSettingsFields } from "./consoleSettingsFields.js";
 
-function buildCreateSchema() {
-  const properties = {};
-  for (const field of consoleSettingsFields) {
-    properties[field.key] = field.required === false ? Type.Optional(field.inputSchema) : field.inputSchema;
-  }
-  return Type.Object(properties, { additionalProperties: false });
-}
-
-function buildOutputSchema() {
-  const properties = {};
-  for (const field of consoleSettingsFields) {
-    properties[field.key] = field.outputSchema;
-  }
-  return Type.Object(properties, { additionalProperties: false });
-}
-
-function buildConsoleSettingsRecordSchema() {
-  return Type.Object(
-    {
-      settings: buildOutputSchema()
-    },
-    { additionalProperties: false }
-  );
-}
-
-function buildConsoleSettingsCreateSchema() {
-  return buildCreateSchema();
-}
-
-function buildConsoleSettingsReplaceSchema() {
-  return buildConsoleSettingsCreateSchema();
-}
-
-function buildConsoleSettingsPatchSchema() {
-  return Type.Partial(buildConsoleSettingsCreateSchema(), {
-    additionalProperties: false
-  });
-}
-
-function normalizeConsoleSettingsInput(payload = {}) {
-  return normalizeSettingsFieldInput(payload, consoleSettingsFields);
-}
-
-const consoleSettingsOutputValidator = Object.freeze({
-  get schema() {
-    return buildConsoleSettingsRecordSchema();
-  },
-  normalize(payload = {}) {
-    const source = normalizeObjectInput(payload);
-    const settingsSource = normalizeObjectInput(source.settings);
-
-    return {
-      settings: normalizeSettingsFieldOutput(settingsSource, consoleSettingsFields)
-    };
+const consoleSettingsBodySchema = createSchema({});
+const consoleSettingsOutputSchema = createSchema({
+  settings: {
+    type: "object",
+    required: true,
+    schema: createSchema({})
   }
 });
 
-const CONSOLE_SETTINGS_OPERATION_MESSAGES = createOperationMessages();
-
-const consoleSettingsResource = Object.freeze({
+const consoleSettingsResource = defineCrudResource({
   namespace: "consoleSettings",
-  operations: Object.freeze({
-    view: Object.freeze({
-      method: "GET",
-      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
-      outputValidator: consoleSettingsOutputValidator
-    }),
-    list: Object.freeze({
-      method: "GET",
-      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
-      outputValidator: createCursorListValidator(consoleSettingsOutputValidator)
-    }),
-    create: Object.freeze({
-      method: "POST",
-      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
-      bodyValidator: Object.freeze({
-        get schema() {
-          return buildConsoleSettingsCreateSchema();
-        },
-        normalize: normalizeConsoleSettingsInput
-      }),
-      outputValidator: consoleSettingsOutputValidator
-    }),
-    replace: Object.freeze({
-      method: "PUT",
-      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
-      bodyValidator: Object.freeze({
-        get schema() {
-          return buildConsoleSettingsReplaceSchema();
-        },
-        normalize: normalizeConsoleSettingsInput
-      }),
-      outputValidator: consoleSettingsOutputValidator
-    }),
-    patch: Object.freeze({
-      method: "PATCH",
-      messages: CONSOLE_SETTINGS_OPERATION_MESSAGES,
-      bodyValidator: Object.freeze({
-        get schema() {
-          return buildConsoleSettingsPatchSchema();
-        },
-        normalize: normalizeConsoleSettingsInput
-      }),
-      outputValidator: consoleSettingsOutputValidator
-    })
-  })
+  messages: createOperationMessages(),
+  crudOperations: ["view", "list", "create", "replace", "patch"],
+  crud: {
+    output: consoleSettingsOutputSchema,
+    body: consoleSettingsBodySchema
+  }
 });
 
 export { consoleSettingsResource };

package/test/bootstrapPayloadIntegration.test.js

@@ -19,7 +19,6 @@ function createAuthenticatedProfile(overrides = {}) {
 
 test("bootstrap payload preserves consoleowner for authenticated users after users bootstrap runs", async () => {
   const profile = createAuthenticatedProfile();
-  const ownerSeeds = [];
   const app = createContainer();
 
   app.instance("internal.repository.user-profiles", {
@@ -43,9 +42,8 @@ test("bootstrap payload preserves consoleowner for authenticated users after use
     clearSessionCookies() {}
   });
   app.instance("consoleService", {
-    async ensureInitialConsoleMember(userId) {
-      ownerSeeds.push(String(userId || ""));
-      return String(userId || "");
+    async isConsoleOwnerUserId(userId) {
+      return String(userId || "") === profile.id;
     }
   });
 
@@ -68,7 +66,6 @@ test("bootstrap payload preserves consoleowner for authenticated users after use
     reply: {}
   });
 
-  assert.deepEqual(ownerSeeds, ["12"]);
   assert.equal(payload.session.authenticated, true);
   assert.equal(payload.session.userId, "12");
   assert.deepEqual(payload.surfaceAccess, {

package/test/consoleAuthServiceDecorator.test.js

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createConsoleAuthServiceDecorator } from "../src/server/consoleAuthServiceDecorator.js";
+
+test("console auth service decorator seeds first owner during session reads only", async () => {
+  const ownerSeeds = [];
+  const decorator = createConsoleAuthServiceDecorator({
+    consoleService: {
+      async ensureInitialConsoleMember(userId) {
+        ownerSeeds.push(String(userId || ""));
+        return String(userId || "");
+      }
+    }
+  });
+
+  const authService = decorator.decorateAuthService({
+    async authenticateRequest(request) {
+      return {
+        authenticated: true,
+        profile: {
+          id: request.profileId
+        }
+      };
+    }
+  });
+
+  await authService.authenticateRequest({
+    profileId: "12",
+    url: "/api/bootstrap"
+  });
+  await authService.authenticateRequest({
+    profileId: "12",
+    url: "/api/session"
+  });
+  await authService.authenticateRequest({
+    profileId: "99",
+    url: "/api/session"
+  });
+
+  assert.deepEqual(ownerSeeds, ["12"]);
+});
+
+test("console auth service decorator leaves unauthenticated session reads alone", async () => {
+  const decorator = createConsoleAuthServiceDecorator({
+    consoleService: {
+      async ensureInitialConsoleMember() {
+        throw new Error("should not seed owner for anonymous session reads");
+      }
+    }
+  });
+
+  const authService = decorator.decorateAuthService({
+    async authenticateRequest() {
+      return {
+        authenticated: false
+      };
+    }
+  });
+
+  const result = await authService.authenticateRequest({
+    url: "/api/session"
+  });
+
+  assert.equal(result.authenticated, false);
+});

package/test/consoleBootstrapContributor.test.js

@@ -2,13 +2,11 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { createConsoleBootstrapContributor } from "../src/server/consoleBootstrapContributor.js";
 
-test("console bootstrap contributor seeds the initial console owner into the existing bootstrap payload", async () => {
-  const ownerSeeds = [];
+test("console bootstrap contributor exposes consoleowner when the authenticated user already owns the console", async () => {
   const contributor = createConsoleBootstrapContributor({
     consoleService: {
-      async ensureInitialConsoleMember(userId) {
-        ownerSeeds.push(String(userId || ""));
-        return String(userId || "");
+      async isConsoleOwnerUserId(userId) {
+        return String(userId || "") === "12";
       }
     }
   });
@@ -26,7 +24,6 @@ test("console bootstrap contributor seeds the initial console owner into the exi
     }
   });
 
-  assert.deepEqual(ownerSeeds, ["12"]);
   assert.deepEqual(contribution, {
     surfaceAccess: {
       existing: true,
@@ -38,7 +35,7 @@ test("console bootstrap contributor seeds the initial console owner into the exi
 test("console bootstrap contributor exposes a false consoleowner flag for anonymous bootstrap", async () => {
   const contributor = createConsoleBootstrapContributor({
     consoleService: {
-      async ensureInitialConsoleMember() {
+      async isConsoleOwnerUserId() {
         throw new Error("should not be called for anonymous payload");
       }
     }

package/test/consoleRouteRequestInputValidator.test.js

@@ -112,8 +112,6 @@ test("console settings route handlers use request.input payloads", async () => {
   assert.equal(calls[0].actionId, "console.settings.read");
   assert.deepEqual(calls[1], {
     actionId: "console.settings.update",
-    input: {
-      payload: {}
-    }
+    input: {}
   });
 });

package/test/consoleRouteResources.test.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { deriveResourceRequiredMetadata } from "@jskit-ai/kernel/_testable";
-import "../test-support/registerDefaultSettingsFields.js";
+import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
 import { consoleSettingsResource } from "../src/shared/resources/consoleSettingsResource.js";
 
 function assertResourceShape(resource, label) {
@@ -26,15 +26,27 @@ function assertResourceShape(resource, label) {
       `${label}.operations.${operationName} must resolve messages from operation.messages or resource.messages.`
     );
     assert.equal(
-      typeof operation.outputValidator?.schema,
+      typeof resolveStructuredSchemaTransportSchema(operation.output, {
+        context: `${label}.operations.${operationName}.output`,
+        defaultMode: "replace"
+      }),
       "object",
       `${label}.operations.${operationName} payload schema is required.`
     );
   }
 
-  assert.equal(typeof resource.operations.create.bodyValidator?.schema, "object", `${label}.operations.create.bodyValidator.schema is required.`);
-  assert.equal(typeof resource.operations.replace.bodyValidator?.schema, "object", `${label}.operations.replace.bodyValidator.schema is required.`);
-  assert.equal(typeof resource.operations.patch.bodyValidator?.schema, "object", `${label}.operations.patch.bodyValidator.schema is required.`);
+  assert.equal(typeof resolveStructuredSchemaTransportSchema(resource.operations.create.body, {
+    context: `${label}.operations.create.body`,
+    defaultMode: "create"
+  }), "object", `${label}.operations.create.body.schema is required.`);
+  assert.equal(typeof resolveStructuredSchemaTransportSchema(resource.operations.replace.body, {
+    context: `${label}.operations.replace.body`,
+    defaultMode: "replace"
+  }), "object", `${label}.operations.replace.body.schema is required.`);
+  assert.equal(typeof resolveStructuredSchemaTransportSchema(resource.operations.patch.body, {
+    context: `${label}.operations.patch.body`,
+    defaultMode: "patch"
+  }), "object", `${label}.operations.patch.body.schema is required.`);
 
   const requiredMetadata = deriveResourceRequiredMetadata(resource);
   assert.ok(Array.isArray(requiredMetadata.create), `${label}.derivedRequired.create must be an array.`);
@@ -50,23 +62,29 @@ test("console settings operations expose canonical validators", () => {
   for (const operationName of ["view", "list", "create", "replace", "patch"]) {
     const operation = consoleSettingsResource.operations?.[operationName];
     assert.equal(typeof operation?.method, "string", `${operationName}.method must exist.`);
-    assert.equal(typeof operation?.outputValidator?.schema, "object", `${operationName}.outputValidator.schema must exist.`);
-    if (operation?.bodyValidator) {
-      assert.equal(typeof operation.bodyValidator.schema, "object", `${operationName}.bodyValidator.schema must exist.`);
+    assert.equal(typeof resolveStructuredSchemaTransportSchema(operation?.output, {
+      context: `${operationName}.output`,
+      defaultMode: "replace"
+    }), "object", `${operationName}.output.schema must exist.`);
+    if (operation?.body) {
+      assert.equal(typeof resolveStructuredSchemaTransportSchema(operation.body, {
+        context: `${operationName}.body`,
+        defaultMode: operationName === "create" ? "create" : operationName === "replace" ? "replace" : "patch"
+      }), "object", `${operationName}.body.schema must exist.`);
     }
   }
 });
 
-test("console-core no longer uses a legacy workspace schema helper path", () => {
+test("console-core does not use workspaceRoutes.js helper path", () => {
   const testFilePath = fileURLToPath(import.meta.url);
   const packageRoot = path.resolve(path.dirname(testFilePath), "..");
-  const legacyWorkspaceRoutesFile = path.join(packageRoot, "src", "server", "common", "routes", "workspaceRoutes.js");
-  assert.equal(existsSync(legacyWorkspaceRoutesFile), false, "workspaceRoutes.js must not exist.");
+  const workspaceRoutesFilePath = path.join(packageRoot, "src", "server", "common", "routes", "workspaceRoutes.js");
+  assert.equal(existsSync(workspaceRoutesFilePath), false, "workspaceRoutes.js must not exist.");
 });
 
-test("console-core route validators do not live under a legacy shared/schema directory", () => {
+test("console-core route validators do not live under src/shared/schema", () => {
   const testFilePath = fileURLToPath(import.meta.url);
   const packageRoot = path.resolve(path.dirname(testFilePath), "..");
-  const legacySchemaDir = path.join(packageRoot, "src", "shared", "schema");
-  assert.equal(existsSync(legacySchemaDir), false, "src/shared/schema must not exist.");
+  const sharedSchemaDirPath = path.join(packageRoot, "src", "shared", "schema");
+  assert.equal(existsSync(sharedSchemaDirPath), false, "src/shared/schema must not exist.");
 });

package/test/consoleService.test.js

@@ -9,6 +9,11 @@ function createFixture(initialOwnerUserId = null) {
 
   const service = createService({
     consoleSettingsRepository: {
+      async getSingleton() {
+        return {
+          ownerUserId: state.ownerUserId
+        };
+      },
       async ensureOwnerUserId(userId) {
         const normalizedUserId = String(userId || "");
         if (!state.ownerUserId) {
@@ -33,6 +38,13 @@ test("consoleService seeds the first authenticated user as console owner", async
   assert.equal(state.ownerUserId, "7");
 });
 
+test("consoleService.isConsoleOwnerUserId reports current ownership without reseeding", async () => {
+  const { service } = createFixture("7");
+
+  assert.equal(await service.isConsoleOwnerUserId("7"), true);
+  assert.equal(await service.isConsoleOwnerUserId("9"), false);
+});
+
 test("consoleService.requireConsoleOwner denies authenticated non-owners", async () => {
   const { service } = createFixture("7");
 

package/test/registerConsoleCore.test.js

@@ -4,10 +4,18 @@ 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 || ""),
@@ -25,12 +33,21 @@ test("registerConsoleCore registers the console action surface alias when action
       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;
     }
   };
 

package/src/shared/resources/consoleSettingsFields.js

@@ -1,56 +0,0 @@
-import { normalizeText } from "@jskit-ai/kernel/shared/actions/textNormalization";
-import { resolveGlobalArrayRegistry } from "./resolveGlobalArrayRegistry.js";
-
-const consoleSettingsFields = resolveGlobalArrayRegistry("jskit.console-core.consoleSettingsFields");
-
-function defineField(field = {}) {
-  const key = normalizeText(field.key);
-  if (!key) {
-    throw new TypeError("consoleSettingsFields.defineField requires field.key.");
-  }
-  if (consoleSettingsFields.some((entry) => entry.key === key)) {
-    throw new Error(`consoleSettingsFields.defineField duplicate key: ${key}`);
-  }
-  if (!field.inputSchema || typeof field.inputSchema !== "object") {
-    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires inputSchema.`);
-  }
-  if (!field.outputSchema || typeof field.outputSchema !== "object") {
-    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires outputSchema.`);
-  }
-  const repositoryColumn = normalizeText(field?.repository?.column);
-  if (!repositoryColumn) {
-    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires repository.column.`);
-  }
-  if (typeof field.normalizeInput !== "function") {
-    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires normalizeInput.`);
-  }
-  if (typeof field.normalizeOutput !== "function") {
-    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires normalizeOutput.`);
-  }
-  if (typeof field.resolveDefault !== "function") {
-    throw new TypeError(`consoleSettingsFields.defineField("${key}") requires resolveDefault.`);
-  }
-
-  consoleSettingsFields.push({
-    key,
-    repository: Object.freeze({
-      column: repositoryColumn
-    }),
-    required: field.required !== false,
-    inputSchema: field.inputSchema,
-    outputSchema: field.outputSchema,
-    normalizeInput: field.normalizeInput,
-    normalizeOutput: field.normalizeOutput,
-    resolveDefault: field.resolveDefault
-  });
-}
-
-function resetConsoleSettingsFields() {
-  consoleSettingsFields.splice(0, consoleSettingsFields.length);
-}
-
-export {
-  defineField,
-  resetConsoleSettingsFields,
-  consoleSettingsFields
-};

package/src/shared/resources/resolveGlobalArrayRegistry.js

@@ -1,6 +0,0 @@
-function resolveGlobalArrayRegistry(symbolKey) {
-  globalThis[symbolKey] = Array.isArray(globalThis[symbolKey]) ? globalThis[symbolKey] : [];
-  return globalThis[symbolKey];
-}
-
-export { resolveGlobalArrayRegistry };

package/templates/packages/main/src/shared/resources/consoleSettingsFields.js

@@ -1,11 +0,0 @@
-// @jskit-contract console.settings-fields.v1
-// Append-only settings field registrations for console settings.
-
-import {
-  defineField,
-  resetConsoleSettingsFields
-} from "@jskit-ai/console-core/shared/resources/consoleSettingsFields";
-
-resetConsoleSettingsFields();
-
-void defineField;

package/test/settingsFieldRegistriesSingleton.test.js

@@ -1,14 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-async function importWithIdentity(url, identity) {
-  return import(`${url.href}?identity=${identity}`);
-}
-
-test("settings field registries stay shared across module identities", async () => {
-  const consoleModuleUrl = new URL("../src/shared/resources/consoleSettingsFields.js", import.meta.url);
-
-  const consoleA = await importWithIdentity(consoleModuleUrl, "console-a");
-  const consoleB = await importWithIdentity(consoleModuleUrl, "console-b");
-  assert.equal(consoleA.consoleSettingsFields, consoleB.consoleSettingsFields);
-});

package/test-support/registerDefaultSettingsFields.js

@@ -1 +0,0 @@
-import "../templates/packages/main/src/shared/resources/consoleSettingsFields.js";