@porulle/core 0.63.0 → 0.65.0

package/src/interfaces/rest/routes/webhooks.ts

@@ -1,7 +1,7 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
 import type { Kernel } from "../../../runtime/kernel.js";
 import { createWebhookEndpointRoute, listWebhookEndpointsRoute, deleteWebhookEndpointRoute } from "../schemas/webhooks.js";
-import { type AppEnv, mapErrorToResponse, mapErrorToStatus, requirePerm } from "../utils.js";
+import { type AppEnv, errorBody, mapErrorToStatus, requirePerm } from "../utils.js";
 
 export function webhookRoutes(kernel: Kernel) {
   const router = new OpenAPIHono<AppEnv>();
@@ -18,7 +18,7 @@ export function webhookRoutes(kernel: Kernel) {
     const actor = c.get("actor");
     const result = await kernel.services.webhooks.createEndpoint(body, actor);
     if (!result.ok) {
-      return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+      return c.json(errorBody(result.error), mapErrorToStatus(result.error));
     }
     return c.json({ data: result.value }, 201);
   });
@@ -27,7 +27,7 @@ export function webhookRoutes(kernel: Kernel) {
   router.openapi(listWebhookEndpointsRoute, async (c) => {
     const result = await kernel.services.webhooks.listEndpoints(c.get("actor"));
     if (!result.ok) {
-      return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+      return c.json(errorBody(result.error), mapErrorToStatus(result.error));
     }
     const sanitized = result.value.map(({ secret: _secret, ...rest }) => rest);
     return c.json({ data: sanitized });
@@ -40,7 +40,7 @@ export function webhookRoutes(kernel: Kernel) {
       c.get("actor"),
     );
     if (!result.ok) {
-      return c.json(mapErrorToResponse(result.error), mapErrorToStatus(result.error));
+      return c.json(errorBody(result.error), mapErrorToStatus(result.error));
     }
     return c.json({ data: { deleted: true } });
   });

package/src/interfaces/rest/utils.ts

@@ -5,6 +5,7 @@ import type { Actor } from "../../auth/types.js";
 import {
   AUTHENTICATION_REQUIRED_MESSAGE,
   isUnauthenticatedActor,
+  hasPermissionFromList,
 } from "../../auth/permissions.js";
 
 export const ROUTE_PERMISSION_GUARD = Symbol("porulle.routePermissionGuard");
@@ -72,7 +73,7 @@ export function parseInclude(value?: string): Set<string> {
  * Map an error to a safe client response. Internal errors are sanitized
  * to prevent leaking SQL, schema, or stack trace details.
  */
-export function mapErrorToResponse(error: unknown): { error: { code: string; message: string } } {
+export function errorBody(error: unknown): { error: { code: string; message: string } } {
   const ce = toCommerceError(error);
   if (ce.code === "INTERNAL_ERROR") {
     // Sanitize internal errors -- do not expose raw messages to clients
@@ -91,14 +92,7 @@ export { mapErrorToStatus };
 export function requirePerm(permission: string) {
   const middleware = async (c: PermissionContext, next: () => Promise<void>) => {
     const actor = c.get("actor");
-    const perms = actor?.permissions ?? [];
-    if (perms.includes(permission) || perms.includes("*:*")) {
-      await next();
-      return;
-    }
-    // Check resource-level wildcard (e.g., "catalog:*" matches "catalog:create")
-    const [resource] = permission.split(":");
-    if (resource && perms.includes(`${resource}:*`)) {
+    if (hasPermissionFromList(actor?.permissions ?? [], permission)) {
       await next();
       return;
     }
@@ -114,11 +108,7 @@ export function requireAnyPerm(permissions: readonly string[]) {
   const middleware = async (c: PermissionContext, next: () => Promise<void>) => {
     const actor = c.get("actor");
     const granted = actor?.permissions ?? [];
-    const allowed = permissions.some((permission) =>
-      granted.includes(permission) ||
-      granted.includes("*:*") ||
-      granted.includes(`${permission.split(":")[0]}:*`),
-    );
+    const allowed = permissions.some((permission) => hasPermissionFromList(granted, permission));
     if (allowed) {
       await next();
       return;

package/src/jobs.ts

@@ -1,5 +1,5 @@
 // Leaf entry for execution engines that run outside Node (Cloudflare Workers):
-// only the job types and the two runtime helpers, none of the server runtime.
+// only the job types and the runtime helpers engines share, none of the server runtime.
 export type {
   JobInstanceStatus,
   TaskContext,
@@ -10,6 +10,7 @@ export type {
 } from "./kernel/jobs/types.js";
 export { TaskNonRetryableError } from "./kernel/jobs/types.js";
 export { createPassThroughTaskStep } from "./kernel/jobs/step.js";
+export { prepareEnqueue, type PreparedEnqueue } from "./kernel/jobs/prepare-enqueue.js";
 export type {
   EnqueueOptions,
   ExecutionEngine,

package/src/kernel/database/adapter.ts

@@ -54,7 +54,7 @@ export function unwrapDb<T>(db: T): T {
  * on the `{ rows }` drivers. We intercept only `execute`; every other method
  * is bound to the real driver instance so its internals are untouched.
  */
-function normalizeExecuteShape<T extends object>(db: T): T {
+export function normalizeExecuteShape<T extends object>(db: T): T {
   return new Proxy(db, {
     get(target, prop, receiver) {
       if (prop === RAW_DB) return target;

package/src/kernel/database/migrate.ts

@@ -64,19 +64,6 @@ export function buildSchema(config?: CommerceConfig): Record<string, unknown> {
   return merged;
 }
 
-/**
- * Returns a list of all schema table names defined by the commerce engine.
- */
-export function getTableNames(): string[] {
-  return Object.entries(schema)
-    .filter(
-      ([_, value]) =>
-        value != null &&
-        typeof value === "object" &&
-        "getSQL" in (value as object),
-    )
-    .map(([key]) => key);
-}
 
 /**
  * Returns the absolute filesystem path(s) of the combined schema module for
@@ -121,10 +108,8 @@ export async function pushSchema(
       "pushSchema() requires `drizzle-kit` to be installed. Add it to your project: bun add -d drizzle-kit",
     );
   }
-  // With a config, push the merged core + plugin schema so plugin-declared
-  // tables are created too; without one, push core only (backward compatible).
-  const schemaToApply = config ? buildSchema(config) : getSchema();
+  // Core plus any plugin-declared tables in `config.customSchemas`.
   // drizzle-kit needs the native driver result shape; unwrap a normalized db.
-  const { apply } = await drizzleKit.pushSchema(schemaToApply, unwrapDb(drizzleInstance));
+  const { apply } = await drizzleKit.pushSchema(buildSchema(config), unwrapDb(drizzleInstance));
   await apply();
 }

package/src/kernel/database/pglite-transaction.ts

@@ -0,0 +1,61 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+/** The one PGlite capability a transaction needs: run a statement on the connection. */
+export interface PGliteExec {
+  exec(statement: string): Promise<unknown>;
+}
+
+/**
+ * `DatabaseAdapter.transaction` for a PGlite instance.
+ *
+ * Drizzle's own `transaction()` can hang on PGlite, so this drives
+ * BEGIN/COMMIT/ROLLBACK directly and hands the body the same `db` handle.
+ *
+ * PGlite is a single connection, so two bodies awaiting concurrently would
+ * otherwise interleave their statements between one BEGIN and one COMMIT —
+ * the second BEGIN is a no-op Postgres only warns about — and share a snapshot,
+ * each other's row locks and each other's rollback. Bodies are queued instead,
+ * which is what a connection pool does to two transactions competing for the
+ * same rows.
+ *
+ * Only a call made from INSIDE a running body joins it (without savepoints that
+ * is the only sound reading of a nested call). "Inside" is decided by the async
+ * context the call runs in, never by whether some transaction happens to be
+ * open: an unrelated request that arrives mid-body queues behind it.
+ */
+export function createPGliteTransaction(pg: PGliteExec, db: unknown): {
+  transaction<T>(fn: (tx: unknown) => Promise<T>): Promise<T>;
+  /** Whether a transaction body is executing right now. */
+  inTransaction(): boolean;
+} {
+  // Each transaction gets its own token; a call joins only when it runs inside
+  // the body of the transaction that is open right now (work a body started
+  // but did not await may outlive it, and must not join a closed transaction).
+  const body = new AsyncLocalStorage<object>();
+  let queue: Promise<unknown> = Promise.resolve();
+  let current: object | null = null;
+
+  async function transaction<T>(fn: (tx: unknown) => Promise<T>): Promise<T> {
+    const caller = body.getStore();
+    if (caller !== undefined && caller === current) return fn(db);
+    const run = queue.then(async () => {
+      await pg.exec("BEGIN");
+      const token = {};
+      current = token;
+      try {
+        const result = await body.run(token, () => fn(db));
+        await pg.exec("COMMIT");
+        return result;
+      } catch (error) {
+        await pg.exec("ROLLBACK");
+        throw error;
+      } finally {
+        current = null;
+      }
+    });
+    queue = run.catch(() => undefined);
+    return run;
+  }
+
+  return { transaction, inTransaction: () => current !== null };
+}

package/src/kernel/database/tx-context.ts

@@ -43,29 +43,11 @@ export async function withTransaction<TDb, TTx, TResult>(
   });
 }
 
-export function reuseOrCreateTxContext<TTx>(
-  tx: TTx,
-  options: WithTransactionOptions,
-  existing?: TxContext<TTx> | null,
-): TxContext<TTx> {
-  if (existing) {
-    return existing;
-  }
-  return createTxContext(tx, options);
-}
-
-function hookContextFromWriteContext(ctx?: CatalogWriteContext): Record<string, unknown> | undefined {
-  return ctx?.hookContext;
-}
-
-function isTransactionalWriteContext<TTx>(ctx: CatalogWriteContext<TTx>): ctx is TxContext<TTx> {
-  return "tx" in ctx && ctx.tx != null;
-}
 
 export function resolveWriteContextHookContext(ctx?: CatalogWriteContext): Record<string, unknown> | undefined {
-  return hookContextFromWriteContext(ctx);
+  return ctx?.hookContext;
 }
 
 export function isWriteContextTransactional<TTx>(ctx?: CatalogWriteContext<TTx>): ctx is TxContext<TTx> {
-  return ctx != null && isTransactionalWriteContext(ctx);
+  return ctx != null && "tx" in ctx && ctx.tx != null;
 }

package/src/kernel/database/unique-violation.ts

@@ -0,0 +1,7 @@
+/** Whether a database error (or any error it wraps) is a Postgres unique violation (23505). */
+export function isUniqueViolation(error: unknown): boolean {
+  if (error == null || typeof error !== "object") return false;
+  const value = error as { code?: unknown; cause?: unknown };
+  if (value.code === "23505") return true;
+  return isUniqueViolation(value.cause);
+}

package/src/kernel/error-mapper.ts

@@ -9,6 +9,7 @@ const statusByCode: Record<string, ContentfulStatusCode> = {
   FORBIDDEN: 403,
   UNAUTHORIZED: 401,
   REAUTH_REQUIRED: 401,
+  TWO_FACTOR_REQUIRED: 403,
   CSRF_ORIGIN_REJECTED: 403,
   CONFLICT: 409,
   INVALID_TRANSITION: 422,

package/src/kernel/errors.ts

@@ -70,6 +70,24 @@ export class CommerceReauthRequiredError extends Error implements CommerceError
   }
 }
 
+/**
+ * Raised for a signed-in member whose role is listed in
+ * `auth.twoFactor.requiredForRoles` but who has not enabled two-factor
+ * authentication. The client discriminates on `code === "TWO_FACTOR_REQUIRED"`
+ * to send the member to enrolment (`/api/auth/two-factor/enable`) rather than
+ * treating it as a plain refusal.
+ */
+export class CommerceTwoFactorRequiredError extends Error implements CommerceError {
+  code = "TWO_FACTOR_REQUIRED" as const;
+  constructor(
+    message: string,
+    public details?: unknown,
+  ) {
+    super(message);
+    this.name = "CommerceTwoFactorRequiredError";
+  }
+}
+
 export class CommerceForbiddenError extends Error implements CommerceError {
   code = "FORBIDDEN" as const;
   constructor(

package/src/kernel/hooks/create-context.ts

@@ -5,6 +5,7 @@ import type { JobsAdapter } from "../jobs/adapter.js";
 import { NullJobsAdapter } from "../jobs/adapter.js";
 import type { PluginDb } from "../database/plugin-types.js";
 import type { HookContext, HookOrigin, Logger, ServiceContainer } from "./types.js";
+import { createConsoleLogger } from "../../utils/logger.js";
 
 export interface CreateHookContextArgs {
   actor: Actor | null;
@@ -16,12 +17,7 @@ export interface CreateHookContextArgs {
   origin?: HookOrigin;
   jobs?: JobsAdapter;
   db?: PluginDb;
-  /** Prefer this over {@link CreateHookContextArgs.kernel}. */
   database?: { db: PluginDb };
-  /**
-   * @deprecated Pass {@link CreateHookContextArgs.database} or {@link CreateHookContextArgs.db} instead.
-   */
-  kernel?: { database: { db: PluginDb } };
   commerceConfig?: CommerceConfig | null;
 }
 
@@ -32,11 +28,11 @@ const nullJobs = new NullJobsAdapter();
  */
 export function createHookContext(args: CreateHookContextArgs): HookContext {
   const db =
-    args.db ?? args.database?.db ?? args.kernel?.database?.db ?? null;
+    args.db ?? args.database?.db ?? null;
 
   if (db == null) {
     throw new Error(
-      "createHookContext requires a database: pass `db`, `database: { db }`, or `kernel: { database: { db } }`.",
+      "createHookContext requires a database: pass `db` or `database: { db }`.",
     );
   }
 
@@ -48,8 +44,42 @@ export function createHookContext(args: CreateHookContextArgs): HookContext {
     context: args.context ?? {},
     requestId: args.requestId ?? randomUUID(),
     origin: args.origin ?? "rest",
-    jobs: args.jobs ?? nullJobs,
+    // The kernel installs its engine as `services.jobs` before any module is
+    // built, so a context that names no engine still enqueues for real. The
+    // null adapter is for a context with no kernel behind it at all.
+    jobs: args.jobs ?? (args.services.jobs as JobsAdapter | undefined) ?? nullJobs,
     db,
     ...(args.commerceConfig !== undefined ? { commerceConfig: args.commerceConfig } : {}),
   };
 }
+
+/** What a core module service already holds that its hook context is built from. */
+export interface ModuleHookDeps {
+  services: ServiceContainer;
+  database: { db: unknown };
+  config: CommerceConfig;
+}
+
+/**
+ * The hook context a core module hands its hooks. Every module builds it the
+ * same way — its name as `context.moduleName` (which webhook event names are
+ * derived from), a logger scoped to it, the kernel's services (and through them
+ * the jobs engine), the database and the config — so none can leave a field out.
+ */
+export function createModuleHookContext(
+  moduleName: string,
+  deps: ModuleHookDeps,
+  actor: Actor | null,
+  tx: unknown = null,
+  options: { logScope?: string; context?: Record<string, unknown> } = {},
+): HookContext {
+  return createHookContext({
+    actor,
+    tx,
+    logger: createConsoleLogger(options.logScope ?? moduleName),
+    services: deps.services,
+    context: { moduleName, ...options.context },
+    database: { db: deps.database.db as PluginDb },
+    commerceConfig: deps.config,
+  });
+}

package/src/kernel/hooks/registry.ts

@@ -33,7 +33,6 @@ type HookEntry = {
 export class HookRegistry {
   private registry = new Map<string, HookEntry>();
   private inTransactionHandlers = new WeakSet<HookHandler>();
-  private logger?: { error: (obj: Record<string, unknown>, msg: string) => void };
 
   registerConfigHooks(hookName: string, handlers: HookHandler[]): void {
     this.ensureEntry(hookName);
@@ -55,11 +54,6 @@ export class HookRegistry {
     this.registry.get(hookName)!.prepended.push(handler);
   }
 
-  prependInTransaction(hookName: string, handler: HookHandler): void {
-    this.inTransactionHandlers.add(handler);
-    this.prepend(hookName, handler);
-  }
-
   runsInTransaction(handler: HookHandler): boolean {
     return this.inTransactionHandlers.has(handler);
   }
@@ -70,37 +64,6 @@ export class HookRegistry {
     return [...entry.prepended, ...entry.configured, ...entry.appended];
   }
 
-  /**
-   * Emit a plugin event to all registered listeners.
-   *
-   * Unlike the before/after hook pattern (which transforms data through
-   * a pipeline), emit is fire-and-forget notification. Errors in handlers
-   * are caught and logged but do not propagate to the emitter.
-   *
-   * Usage:
-   *   kernel.hooks.emit("production.afterComplete", { orderId, quantity });
-   *
-   * Any plugin can listen:
-   *   hooks: () => [{ key: "production.afterComplete", handler: async (payload) => { ... } }]
-   */
-  setLogger(logger: { error: (obj: Record<string, unknown>, msg: string) => void }): void {
-    this.logger = logger;
-  }
-
-  async emit(key: string, payload: unknown): Promise<void> {
-    const handlers = this.resolve(key);
-    for (const handler of handlers) {
-      try {
-        await (handler as (payload: unknown) => unknown)(payload);
-      } catch (err) {
-        this.logger?.error(
-          { err, hookKey: key },
-          `Event handler failed for "${key}"`,
-        );
-      }
-    }
-  }
-
   private ensureEntry(hookName: string): void {
     if (!this.registry.has(hookName)) {
       this.registry.set(hookName, {

package/src/kernel/jobs/drizzle-adapter.ts

@@ -7,8 +7,9 @@ import type {
   ExecutionEngineSetup,
   RunJobsOptions,
 } from "./adapter.js";
-import { OrgResolutionError, CommerceNotFoundError } from "../errors.js";
+import { CommerceNotFoundError } from "../errors.js";
 import { commerceJobs } from "./schema.js";
+import { prepareEnqueue } from "./prepare-enqueue.js";
 import { runPendingJobs } from "./runner.js";
 import {
   getJobReapThresholdMs,
@@ -79,17 +80,8 @@ export class DrizzleJobsAdapter implements ExecutionEngine {
     input: Record<string, unknown>,
     options: EnqueueOptions,
   ): Promise<string> {
-    const organizationId = options.organizationId.trim();
-    if (!organizationId) {
-      throw new OrgResolutionError(
-        "Jobs enqueue requires a non-empty organizationId.",
-      );
-    }
-
-    const task = this.tasks.get(taskSlug);
-    const concurrencyKey =
-      options.concurrencyKey ?? task?.concurrency?.key(input);
-    const supersedes = options.supersedes ?? task?.concurrency?.supersedes;
+    const { organizationId, concurrencyKey, supersedes, maxAttempts } =
+      prepareEnqueue(this.tasks, taskSlug, input, options);
 
     // If supersedes is set, delete existing pending jobs with the same concurrency key
     if (concurrencyKey && supersedes) {
@@ -105,9 +97,6 @@ export class DrizzleJobsAdapter implements ExecutionEngine {
         );
     }
 
-    // Look up task definition for default retry config
-    const maxAttempts = options.maxAttempts ?? task?.retries?.attempts ?? 1;
-
     const rows = await this.db
       .insert(commerceJobs)
       .values({

package/src/kernel/jobs/prepare-enqueue.ts

@@ -0,0 +1,42 @@
+import { OrgResolutionError } from "../errors.js";
+import type { EnqueueOptions } from "./adapter.js";
+import type { TaskDefinition } from "./types.js";
+
+export interface PreparedEnqueue {
+  task: TaskDefinition;
+  organizationId: string;
+  concurrencyKey: string | undefined;
+  /** At most one running job per concurrency key. */
+  exclusive: boolean;
+  /** A newer enqueue replaces a pending one with the same concurrency key. */
+  supersedes: boolean;
+  maxAttempts: number;
+}
+
+/**
+ * The validation and defaulting every execution engine applies before it hands
+ * a job to its backend: the task must be registered, the organization must be
+ * non-blank, and concurrency/retry settings come from the task unless the
+ * enqueue call overrides them.
+ */
+export function prepareEnqueue(
+  tasks: ReadonlyMap<string, TaskDefinition>,
+  taskSlug: string,
+  input: Record<string, unknown>,
+  options: EnqueueOptions,
+): PreparedEnqueue {
+  const task = tasks.get(taskSlug);
+  if (!task) throw new Error(`Unknown task slug: ${taskSlug}`);
+  const organizationId = options.organizationId.trim();
+  if (!organizationId) {
+    throw new OrgResolutionError("Jobs enqueue requires a non-empty organizationId.");
+  }
+  return {
+    task,
+    organizationId,
+    concurrencyKey: options.concurrencyKey ?? task.concurrency?.key(input),
+    exclusive: Boolean(task.concurrency && task.concurrency.exclusive !== false),
+    supersedes: Boolean(options.supersedes ?? task.concurrency?.supersedes),
+    maxAttempts: options.maxAttempts ?? task.retries?.attempts ?? 1,
+  };
+}

package/src/kernel/jobs/types.ts

@@ -1,11 +1,6 @@
 import type { Logger, ServiceContainer } from "../hooks/types.js";
 import type { DrizzleDatabase } from "../database/drizzle-db.js";
 
-export const BUILTIN_JOB_TASK_SLUGS = {
-  webhookDeliver: "webhooks/deliver",
-  staleJobReaper: "jobs/reap-stale",
-} as const;
-
 export interface TaskContext {
   logger: Logger;
   db: DrizzleDatabase;

package/src/kernel/local-api.ts

@@ -142,47 +142,3 @@ export function createLocalAPI(
     },
   });
 }
-
-// ─── Legacy Class API (backward compat) ─────────────────────────────────────
-
-/**
- * @deprecated Use `createLocalAPI(kernel, { actor, tx })` instead.
- * Kept for backward compatibility with existing hook code.
- */
-export class LocalAPI {
-  private _proxy: CommerceLocalAPI;
-
-  constructor(
-    ctx: { actor: Actor | null; tx: unknown; requestId: string },
-    kernel: Kernel,
-  ) {
-    this._proxy = createLocalAPI(kernel, {
-      actor: ctx.actor,
-      tx: ctx.tx,
-      requestId: ctx.requestId,
-    });
-  }
-
-  get orders() { return this._proxy.orders; }
-  get catalog() { return this._proxy.catalog; }
-  get cart() { return this._proxy.cart; }
-  get inventory() { return this._proxy.inventory; }
-  get customers() { return this._proxy.customers; }
-  get pricing() { return this._proxy.pricing; }
-  get promotions() { return this._proxy.promotions; }
-  get media() { return this._proxy.media; }
-  get shipping() { return this._proxy.shipping; }
-  get search() { return this._proxy.search; }
-  get webhooks() { return this._proxy.webhooks; }
-  get fulfillment() { return this._proxy.fulfillment; }
-  get payments() { return this._proxy.payments; }
-  get analytics() { return this._proxy.analytics; }
-  get tax() { return this._proxy.tax; }
-  get audit() { return this._proxy.audit; }
-  get organization() { return this._proxy.organization; }
-
-  /** Resolve a service by name from `kernel.services`. */
-  service(name: string) {
-    return (this._proxy as Record<string, unknown>)[name];
-  }
-}

package/src/kernel/plugin/manifest.ts

@@ -18,14 +18,12 @@ import type {
   PluginPermission,
 } from "../../config/types.js";
 import type { TaskDefinition } from "../jobs/types.js";
+import type { Logger } from "../hooks/types.js";
 
 // ─── Plugin Logger ────────────────────────────────────────────────────
 
-export interface PluginLogger {
-  info(message: string, data?: unknown): void;
-  warn(message: string, data?: unknown): void;
-  error(message: string, data?: unknown): void;
-}
+/** The logger a plugin receives — the same shape every hook and job gets. */
+export type PluginLogger = Logger;
 
 // ─── Plugin Registration Types ────────────────────────────────────────
 

package/src/modules/analytics/service.ts

@@ -93,33 +93,6 @@ export class AnalyticsService {
     return this.deps.adapter.query(params, scope);
   }
 
-  async getDashboard(name: string, scope: AnalyticsScope): Promise<Result<AnalyticsQueryResult>> {
-    const normalized = name.trim().toLowerCase();
-
-    if (normalized === "revenue" || normalized === "revenue-overview") {
-      return this.query({
-        measures: ["Orders.revenue", "Orders.count"],
-        timeDimensions: [{
-          dimension: "Orders.placedAt",
-          granularity: "month",
-          dateRange: "this month",
-        }],
-        order: { "Orders.placedAt": "asc" },
-      }, scope);
-    }
-
-    if (normalized === "inventory" || normalized === "inventory-health") {
-      return this.query({
-        measures: ["Inventory.totalAvailable", "Inventory.lowStockCount"],
-        dimensions: ["Inventory.warehouseId"],
-        order: { "Inventory.totalAvailable": "desc" },
-      }, scope);
-    }
-
-    return Err(
-      new CommerceValidationError(`Unknown analytics dashboard: ${name}`),
-    );
-  }
 
   /** The canned retail reports pack (issue #48). */
   listReports(): Array<{ name: string; description: string }> {
@@ -161,15 +134,6 @@ export class AnalyticsService {
     });
   }
 
-  async meta(): Promise<Result<{ measures: string[]; dimensions: string[]; segments: string[] }>> {
-    const meta = await this.getMeta();
-    if (!meta.ok) return meta;
-    return Ok({
-      measures: meta.value.measures,
-      dimensions: meta.value.dimensions,
-      segments: meta.value.segments,
-    });
-  }
 
   // ─── Private ─────────────────────────────────────────────────────────────