@objectstack/runtime 8.0.1 → 9.0.1

package/dist/index.js

@@ -143,601 +143,10 @@ var seed_loader_exports = {};
 __export(seed_loader_exports, {
   SeedLoaderService: () => SeedLoaderService
 });
-import { SeedLoaderConfigSchema } from "@objectstack/spec/data";
-import { resolveSeedRecord } from "@objectstack/formula";
-var DEFAULT_EXTERNAL_ID_FIELD, _SeedLoaderService, SeedLoaderService;
+import { SeedLoaderService } from "@objectstack/objectql";
 var init_seed_loader = __esm({
   "src/seed-loader.ts"() {
     "use strict";
-    DEFAULT_EXTERNAL_ID_FIELD = "name";
-    _SeedLoaderService = class _SeedLoaderService {
-      constructor(engine, metadata, logger) {
-        this.engine = engine;
-        this.metadata = metadata;
-        this.logger = logger;
-      }
-      // ==========================================================================
-      // Public API
-      // ==========================================================================
-      async load(request) {
-        const startTime = Date.now();
-        const config = request.config;
-        const allErrors = [];
-        const allResults = [];
-        const datasets = this.filterByEnv(request.seeds, config.env);
-        if (datasets.length === 0) {
-          return this.buildEmptyResult(config, Date.now() - startTime);
-        }
-        const objectNames = datasets.map((d) => d.object);
-        const graph = await this.buildDependencyGraph(objectNames);
-        this.logger.info("[SeedLoader] Dependency graph built", {
-          objects: objectNames.length,
-          insertOrder: graph.insertOrder,
-          circularDeps: graph.circularDependencies.length
-        });
-        const orderedDatasets = this.orderDatasets(datasets, graph.insertOrder);
-        const refMap = this.buildReferenceMap(graph);
-        const insertedRecords = /* @__PURE__ */ new Map();
-        const deferredUpdates = [];
-        for (const dataset of orderedDatasets) {
-          const result = await this.loadDataset(
-            dataset,
-            config,
-            refMap,
-            insertedRecords,
-            deferredUpdates,
-            allErrors
-          );
-          allResults.push(result);
-          if (config.haltOnError && result.errored > 0) {
-            this.logger.warn("[SeedLoader] Halting on first error", { object: dataset.object });
-            break;
-          }
-        }
-        if (config.multiPass && deferredUpdates.length > 0 && !config.dryRun) {
-          this.logger.info("[SeedLoader] Pass 2: resolving deferred references", {
-            count: deferredUpdates.length
-          });
-          await this.resolveDeferredUpdates(deferredUpdates, insertedRecords, allResults, allErrors, config.organizationId);
-        }
-        const durationMs = Date.now() - startTime;
-        return this.buildResult(config, graph, allResults, allErrors, durationMs);
-      }
-      async buildDependencyGraph(objectNames) {
-        const nodes = [];
-        const objectSet = new Set(objectNames);
-        for (const objectName of objectNames) {
-          const objDef = await this.metadata.getObject(objectName);
-          const dependsOn = [];
-          const references = [];
-          if (objDef && objDef.fields) {
-            const fields = objDef.fields;
-            for (const [fieldName, fieldDef] of Object.entries(fields)) {
-              if ((fieldDef.type === "lookup" || fieldDef.type === "master_detail") && fieldDef.reference) {
-                const targetObject = fieldDef.reference;
-                if (objectSet.has(targetObject) && !dependsOn.includes(targetObject)) {
-                  dependsOn.push(targetObject);
-                }
-                references.push({
-                  field: fieldName,
-                  targetObject,
-                  targetField: DEFAULT_EXTERNAL_ID_FIELD,
-                  fieldType: fieldDef.type
-                });
-              }
-            }
-          }
-          nodes.push({ object: objectName, dependsOn, references });
-        }
-        const { insertOrder, circularDependencies } = this.topologicalSort(nodes);
-        return { nodes, insertOrder, circularDependencies };
-      }
-      async validate(datasets, config) {
-        const parsedConfig = SeedLoaderConfigSchema.parse({ ...config, dryRun: true });
-        return this.load({ seeds: datasets, config: parsedConfig });
-      }
-      // ==========================================================================
-      // Internal: Seed Loading
-      // ==========================================================================
-      async loadDataset(dataset, config, refMap, insertedRecords, deferredUpdates, allErrors) {
-        const objectName = dataset.object;
-        const mode = dataset.mode || config.defaultMode;
-        const externalId = dataset.externalId || "name";
-        let inserted = 0;
-        let updated = 0;
-        let skipped = 0;
-        let errored = 0;
-        let referencesResolved = 0;
-        let referencesDeferred = 0;
-        const errors = [];
-        if (!insertedRecords.has(objectName)) {
-          insertedRecords.set(objectName, /* @__PURE__ */ new Map());
-        }
-        let existingRecords;
-        if ((mode === "upsert" || mode === "update" || mode === "ignore") && !config.dryRun) {
-          existingRecords = await this.loadExistingRecords(
-            objectName,
-            externalId,
-            config.organizationId
-          );
-        }
-        const objectRefs = refMap.get(objectName) || [];
-        const seedNow = /* @__PURE__ */ new Date();
-        const seedIdentity = config.identity;
-        const baseEvalCtx = {
-          now: seedNow,
-          user: seedIdentity?.user,
-          // Fall back to the per-tenant organizationId so `os.org.id` resolves
-          // during per-org replay even without an explicit identity.org.
-          org: seedIdentity?.org ?? (config.organizationId ? { id: config.organizationId } : void 0),
-          env: config.env
-        };
-        for (let i = 0; i < dataset.records.length; i++) {
-          const seedResult = resolveSeedRecord(
-            dataset.records[i],
-            baseEvalCtx
-          );
-          if (!seedResult.ok) {
-            errored++;
-            const error = {
-              sourceObject: objectName,
-              field: "(expression)",
-              targetObject: objectName,
-              targetField: "(expression)",
-              attemptedValue: dataset.records[i],
-              recordIndex: i,
-              message: `Cannot resolve dynamic seed values for ${objectName} record #${i}: ${seedResult.error.message}. Records using cel\`os.user.id\` / cel\`os.org.id\` require a seed identity \u2014 ensure a system/admin user exists before seeding (see SeedLoaderConfig.identity).`
-            };
-            errors.push(error);
-            allErrors.push(error);
-            this.logger.warn(`[SeedLoader] ${error.message}`);
-            continue;
-          }
-          const record = { ...seedResult.value };
-          if (config.organizationId && record["organization_id"] == null) {
-            record["organization_id"] = config.organizationId;
-          }
-          for (const ref of objectRefs) {
-            const fieldValue = record[ref.field];
-            if (fieldValue === void 0 || fieldValue === null) continue;
-            if (typeof fieldValue === "object") {
-              const wrapped = fieldValue.externalId;
-              const hint = wrapped !== void 0 ? ` Pass the natural key directly: ${ref.field}: ${JSON.stringify(wrapped)}.` : ` Pass the target's ${ref.targetField} value as a plain string.`;
-              const error = {
-                sourceObject: objectName,
-                field: ref.field,
-                targetObject: ref.targetObject,
-                targetField: ref.targetField,
-                attemptedValue: fieldValue,
-                recordIndex: i,
-                message: `Invalid reference for ${objectName}.${ref.field}: expected a ${ref.targetObject}.${ref.targetField} natural-key string but got an object.${hint}`
-              };
-              errors.push(error);
-              allErrors.push(error);
-              this.logger.warn(`[SeedLoader] ${error.message}`, { recordIndex: i });
-              record[ref.field] = null;
-              continue;
-            }
-            if (typeof fieldValue !== "string" || this.looksLikeInternalId(fieldValue)) continue;
-            const targetMap = insertedRecords.get(ref.targetObject);
-            const resolvedId = targetMap?.get(String(fieldValue));
-            if (resolvedId) {
-              record[ref.field] = resolvedId;
-              referencesResolved++;
-            } else if (!config.dryRun) {
-              const dbId = await this.resolveFromDatabase(ref.targetObject, ref.targetField, fieldValue, config.organizationId);
-              if (dbId) {
-                record[ref.field] = dbId;
-                referencesResolved++;
-              } else if (config.multiPass) {
-                record[ref.field] = null;
-                deferredUpdates.push({
-                  objectName,
-                  recordExternalId: String(record[externalId] ?? ""),
-                  field: ref.field,
-                  targetObject: ref.targetObject,
-                  targetField: ref.targetField,
-                  attemptedValue: fieldValue,
-                  recordIndex: i
-                });
-                referencesDeferred++;
-              } else {
-                const error = {
-                  sourceObject: objectName,
-                  field: ref.field,
-                  targetObject: ref.targetObject,
-                  targetField: ref.targetField,
-                  attemptedValue: fieldValue,
-                  recordIndex: i,
-                  message: `Cannot resolve reference: ${objectName}.${ref.field} = '${fieldValue}' \u2192 ${ref.targetObject}.${ref.targetField} not found`
-                };
-                errors.push(error);
-                allErrors.push(error);
-              }
-            } else {
-              const targetMap2 = insertedRecords.get(ref.targetObject);
-              if (!targetMap2?.has(String(fieldValue))) {
-                const error = {
-                  sourceObject: objectName,
-                  field: ref.field,
-                  targetObject: ref.targetObject,
-                  targetField: ref.targetField,
-                  attemptedValue: fieldValue,
-                  recordIndex: i,
-                  message: `[dry-run] Reference may not resolve: ${objectName}.${ref.field} = '${fieldValue}' \u2192 ${ref.targetObject}.${ref.targetField}`
-                };
-                errors.push(error);
-                allErrors.push(error);
-              }
-            }
-          }
-          if (!config.dryRun) {
-            try {
-              const result = await this.writeRecord(
-                objectName,
-                record,
-                mode,
-                externalId,
-                existingRecords
-              );
-              if (result.action === "inserted") inserted++;
-              else if (result.action === "updated") updated++;
-              else if (result.action === "skipped") skipped++;
-              const externalIdValue = String(record[externalId] ?? "");
-              const internalId = result.id;
-              if (externalIdValue && internalId) {
-                insertedRecords.get(objectName).set(externalIdValue, String(internalId));
-              }
-            } catch (err) {
-              errored++;
-              const error = {
-                sourceObject: objectName,
-                field: "(write)",
-                targetObject: objectName,
-                targetField: externalId,
-                attemptedValue: record[externalId] ?? null,
-                recordIndex: i,
-                message: `Failed to write ${objectName} record #${i} (${externalId}=${String(record[externalId] ?? "")}): ${err.message}`
-              };
-              errors.push(error);
-              allErrors.push(error);
-              this.logger.warn(`[SeedLoader] ${error.message}`, { recordIndex: i });
-            }
-          } else {
-            const externalIdValue = String(record[externalId] ?? "");
-            if (externalIdValue) {
-              insertedRecords.get(objectName).set(externalIdValue, `dry-run-id-${i}`);
-            }
-            inserted++;
-          }
-        }
-        return {
-          object: objectName,
-          mode,
-          inserted,
-          updated,
-          skipped,
-          errored,
-          total: dataset.records.length,
-          referencesResolved,
-          referencesDeferred,
-          errors
-        };
-      }
-      // ==========================================================================
-      // Internal: Reference Resolution
-      // ==========================================================================
-      async resolveFromDatabase(targetObject, targetField, value, organizationId) {
-        try {
-          const where = { [targetField]: value };
-          if (organizationId) where.organization_id = organizationId;
-          const records = await this.engine.find(targetObject, {
-            where,
-            fields: ["id"],
-            limit: 1,
-            context: { isSystem: true }
-          });
-          if (records && records.length > 0) {
-            return String(records[0].id || records[0]._id);
-          }
-        } catch {
-        }
-        return null;
-      }
-      async resolveDeferredUpdates(deferredUpdates, insertedRecords, allResults, allErrors, organizationId) {
-        for (const deferred of deferredUpdates) {
-          const targetMap = insertedRecords.get(deferred.targetObject);
-          let resolvedId = targetMap?.get(String(deferred.attemptedValue));
-          if (!resolvedId) {
-            resolvedId = await this.resolveFromDatabase(
-              deferred.targetObject,
-              deferred.targetField,
-              deferred.attemptedValue,
-              organizationId
-            ) ?? void 0;
-          }
-          if (resolvedId) {
-            const objectRecordMap = insertedRecords.get(deferred.objectName);
-            const recordId = objectRecordMap?.get(deferred.recordExternalId);
-            if (recordId) {
-              try {
-                await this.engine.update(deferred.objectName, {
-                  id: recordId,
-                  [deferred.field]: resolvedId
-                }, { context: { isSystem: true } });
-                const resultEntry = allResults.find((r) => r.object === deferred.objectName);
-                if (resultEntry) {
-                  resultEntry.referencesResolved++;
-                  resultEntry.referencesDeferred--;
-                }
-              } catch (err) {
-                this.logger.warn("[SeedLoader] Failed to resolve deferred reference", {
-                  object: deferred.objectName,
-                  field: deferred.field,
-                  error: err.message
-                });
-              }
-            }
-          } else {
-            const error = {
-              sourceObject: deferred.objectName,
-              field: deferred.field,
-              targetObject: deferred.targetObject,
-              targetField: deferred.targetField,
-              attemptedValue: deferred.attemptedValue,
-              recordIndex: deferred.recordIndex,
-              message: `Deferred reference unresolved after pass 2: ${deferred.objectName}.${deferred.field} = '${deferred.attemptedValue}' \u2192 ${deferred.targetObject}.${deferred.targetField} not found`
-            };
-            const resultEntry = allResults.find((r) => r.object === deferred.objectName);
-            if (resultEntry) {
-              resultEntry.errors.push(error);
-            }
-            allErrors.push(error);
-          }
-        }
-      }
-      async writeRecord(objectName, record, mode, externalId, existingRecords) {
-        const externalIdValue = record[externalId];
-        const existing = existingRecords?.get(String(externalIdValue ?? ""));
-        const opts = _SeedLoaderService.SEED_OPTIONS;
-        switch (mode) {
-          case "insert": {
-            const result = await this.engine.insert(objectName, record, opts);
-            return { action: "inserted", id: this.extractId(result) };
-          }
-          case "update": {
-            if (!existing) {
-              return { action: "skipped" };
-            }
-            const id = this.extractId(existing);
-            await this.engine.update(objectName, { ...record, id }, opts);
-            return { action: "updated", id };
-          }
-          case "upsert": {
-            if (existing) {
-              const id = this.extractId(existing);
-              await this.engine.update(objectName, { ...record, id }, opts);
-              return { action: "updated", id };
-            } else {
-              const result = await this.engine.insert(objectName, record, opts);
-              return { action: "inserted", id: this.extractId(result) };
-            }
-          }
-          case "ignore": {
-            if (existing) {
-              return { action: "skipped", id: this.extractId(existing) };
-            }
-            const result = await this.engine.insert(objectName, record, opts);
-            return { action: "inserted", id: this.extractId(result) };
-          }
-          case "replace": {
-            const result = await this.engine.insert(objectName, record, opts);
-            return { action: "inserted", id: this.extractId(result) };
-          }
-          default: {
-            const result = await this.engine.insert(objectName, record, opts);
-            return { action: "inserted", id: this.extractId(result) };
-          }
-        }
-      }
-      // ==========================================================================
-      // Internal: Dependency Graph
-      // ==========================================================================
-      /**
-       * Kahn's algorithm for topological sort with cycle detection.
-       */
-      topologicalSort(nodes) {
-        const inDegree = /* @__PURE__ */ new Map();
-        const adjacency = /* @__PURE__ */ new Map();
-        const objectSet = new Set(nodes.map((n) => n.object));
-        for (const node of nodes) {
-          inDegree.set(node.object, 0);
-          adjacency.set(node.object, []);
-        }
-        for (const node of nodes) {
-          for (const dep of node.dependsOn) {
-            if (objectSet.has(dep) && dep !== node.object) {
-              adjacency.get(dep).push(node.object);
-              inDegree.set(node.object, (inDegree.get(node.object) || 0) + 1);
-            }
-          }
-        }
-        const queue = [];
-        for (const [obj, degree] of inDegree) {
-          if (degree === 0) queue.push(obj);
-        }
-        const insertOrder = [];
-        while (queue.length > 0) {
-          const current = queue.shift();
-          insertOrder.push(current);
-          for (const neighbor of adjacency.get(current) || []) {
-            const newDegree = (inDegree.get(neighbor) || 0) - 1;
-            inDegree.set(neighbor, newDegree);
-            if (newDegree === 0) {
-              queue.push(neighbor);
-            }
-          }
-        }
-        const circularDependencies = [];
-        const remaining = nodes.filter((n) => !insertOrder.includes(n.object));
-        if (remaining.length > 0) {
-          const cycles = this.findCycles(remaining);
-          circularDependencies.push(...cycles);
-          for (const node of remaining) {
-            if (!insertOrder.includes(node.object)) {
-              insertOrder.push(node.object);
-            }
-          }
-        }
-        return { insertOrder, circularDependencies };
-      }
-      findCycles(nodes) {
-        const cycles = [];
-        const nodeMap = new Map(nodes.map((n) => [n.object, n]));
-        const visited = /* @__PURE__ */ new Set();
-        const inStack = /* @__PURE__ */ new Set();
-        const dfs = (current, path) => {
-          if (inStack.has(current)) {
-            const cycleStart = path.indexOf(current);
-            if (cycleStart !== -1) {
-              cycles.push([...path.slice(cycleStart), current]);
-            }
-            return;
-          }
-          if (visited.has(current)) return;
-          visited.add(current);
-          inStack.add(current);
-          path.push(current);
-          const node = nodeMap.get(current);
-          if (node) {
-            for (const dep of node.dependsOn) {
-              if (nodeMap.has(dep)) {
-                dfs(dep, [...path]);
-              }
-            }
-          }
-          inStack.delete(current);
-        };
-        for (const node of nodes) {
-          if (!visited.has(node.object)) {
-            dfs(node.object, []);
-          }
-        }
-        return cycles;
-      }
-      // ==========================================================================
-      // Internal: Helpers
-      // ==========================================================================
-      filterByEnv(datasets, env) {
-        if (!env) return datasets;
-        return datasets.filter((d) => d.env.includes(env));
-      }
-      orderDatasets(datasets, insertOrder) {
-        const orderMap = new Map(insertOrder.map((name, i) => [name, i]));
-        return [...datasets].sort((a, b) => {
-          const orderA = orderMap.get(a.object) ?? Number.MAX_SAFE_INTEGER;
-          const orderB = orderMap.get(b.object) ?? Number.MAX_SAFE_INTEGER;
-          return orderA - orderB;
-        });
-      }
-      buildReferenceMap(graph) {
-        const map = /* @__PURE__ */ new Map();
-        for (const node of graph.nodes) {
-          if (node.references.length > 0) {
-            map.set(node.object, node.references);
-          }
-        }
-        return map;
-      }
-      async loadExistingRecords(objectName, externalId, organizationId) {
-        const map = /* @__PURE__ */ new Map();
-        try {
-          const findArgs = {
-            fields: ["id", externalId],
-            context: { isSystem: true }
-          };
-          if (organizationId) findArgs.where = { organization_id: organizationId };
-          const records = await this.engine.find(objectName, findArgs);
-          for (const record of records || []) {
-            const key = String(record[externalId] ?? "");
-            if (key) {
-              map.set(key, record);
-            }
-          }
-        } catch {
-        }
-        return map;
-      }
-      looksLikeInternalId(value) {
-        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)) {
-          return true;
-        }
-        if (/^[0-9a-f]{24}$/i.test(value)) {
-          return true;
-        }
-        return false;
-      }
-      extractId(record) {
-        if (!record) return void 0;
-        return String(record.id || record._id || "");
-      }
-      buildEmptyResult(config, durationMs) {
-        return {
-          success: true,
-          dryRun: config.dryRun,
-          dependencyGraph: { nodes: [], insertOrder: [], circularDependencies: [] },
-          results: [],
-          errors: [],
-          summary: {
-            objectsProcessed: 0,
-            totalRecords: 0,
-            totalInserted: 0,
-            totalUpdated: 0,
-            totalSkipped: 0,
-            totalErrored: 0,
-            totalReferencesResolved: 0,
-            totalReferencesDeferred: 0,
-            circularDependencyCount: 0,
-            durationMs
-          }
-        };
-      }
-      buildResult(config, graph, results, errors, durationMs) {
-        const summary = {
-          objectsProcessed: results.length,
-          totalRecords: results.reduce((sum, r) => sum + r.total, 0),
-          totalInserted: results.reduce((sum, r) => sum + r.inserted, 0),
-          totalUpdated: results.reduce((sum, r) => sum + r.updated, 0),
-          totalSkipped: results.reduce((sum, r) => sum + r.skipped, 0),
-          totalErrored: results.reduce((sum, r) => sum + r.errored, 0),
-          totalReferencesResolved: results.reduce((sum, r) => sum + r.referencesResolved, 0),
-          totalReferencesDeferred: results.reduce((sum, r) => sum + r.referencesDeferred, 0),
-          circularDependencyCount: graph.circularDependencies.length,
-          durationMs
-        };
-        const hasErrors = errors.length > 0 || summary.totalErrored > 0;
-        return {
-          success: !hasErrors,
-          dryRun: config.dryRun,
-          dependencyGraph: graph,
-          results,
-          errors,
-          summary
-        };
-      }
-    };
-    // ==========================================================================
-    // Internal: Write Operations
-    // ==========================================================================
-    /**
-     * Seed writes always run as a privileged system context. This bypasses
-     * RBAC checks (so seeds can target system tables like `sys_*`) and
-     * disables the SecurityPlugin's auto-injection of `organization_id` /
-     * `owner_id` — seeds either declare those fields explicitly per
-     * record, or are intentionally cross-tenant / global.
-     */
-    _SeedLoaderService.SEED_OPTIONS = { context: { isSystem: true } };
-    SeedLoaderService = _SeedLoaderService;
   }
 });
 
@@ -972,7 +381,7 @@ var init_quickjs_runner = __esm({
           evalRes.value.dispose();
           let pumps = 0;
           while (pumps < 1e3) {
-            await new Promise((resolve2) => setImmediate(resolve2));
+            await new Promise((resolve) => setImmediate(resolve));
             const pending = runtime.executePendingJobs();
             if (pending.error) {
               const err = vm.dump(pending.error);
@@ -1751,8 +1160,8 @@ var init_app_plugin = __esm({
                 }
               })();
               let timer;
-              const budget = new Promise((resolve2) => {
-                timer = setTimeout(() => resolve2("budget"), seedBudgetMs);
+              const budget = new Promise((resolve) => {
+                timer = setTimeout(() => resolve("budget"), seedBudgetMs);
               });
               const winner = await Promise.race([seedPromise.then(() => "done"), budget]);
               if (timer) clearTimeout(timer);
@@ -2644,7 +2053,13 @@ function randomUUID() {
   });
 }
 var _HttpDispatcher = class _HttpDispatcher {
-  constructor(kernel, envRegistry, options) {
+  /**
+   * @param _envRegistryIgnored — RETIRED (ADR-0006 Phase 5). Environment
+   * resolution moved behind the host's {@link KernelResolver}; the
+   * positional parameter is kept so existing 3-arg callers keep compiling,
+   * but its value is ignored.
+   */
+  constructor(kernel, _envRegistryIgnored, options) {
     /**
      * In-memory cache of positive membership checks, keyed by
      * `${environmentId}:${userId}`. Entries expire 60 seconds after insertion
@@ -2661,9 +2076,8 @@ var _HttpDispatcher = class _HttpDispatcher {
         return void 0;
       }
     };
-    this.envRegistry = envRegistry ?? resolveService("env-registry");
     this.enforceMembership = options?.enforceProjectMembership ?? true;
-    this.kernelManager = options?.kernelManager ?? resolveService("kernel-manager");
+    this.kernelResolver = options?.kernelResolver ?? resolveService("kernel-resolver");
     this.scopeManager = options?.scopeManager ?? resolveService("scope-manager");
   }
   resolveDefaultProject() {
@@ -3051,130 +2465,20 @@ var _HttpDispatcher = class _HttpDispatcher {
     return candidate;
   }
   /**
-   * Resolve environment context for incoming request.
+   * Attach the dispatcher's parsing hints for the host's
+   * {@link KernelResolver} (ADR-0006 Phase 5).
    *
-   * Precedence:
-   * 0. URL path matches `/environments/:environmentId/...` OR request.params.environmentId set by router
-   *    → envRegistry.resolveById(id)
-   * 1. request.headers.host → envRegistry.resolveByHostname(host)
-   * 2. request.headers['x-environment-id'] → envRegistry.resolveById(id)
-   * 3. session.activeEnvironmentId → envRegistry.resolveById(id)
-   * 4. session.activeOrganizationId → find default project → envRegistry.resolveById(id)
-   * 5. single-environment default (registered by `createSingleEnvironmentPlugin`)
-   *    → envRegistry.resolveById(defaultProject.environmentId). Lets bare
-   *    `/api/v1/data/...` URLs resolve to the lone project in
-   *    `cloudUrl: 'local'` deployments.
-   *
-   * Skip for paths: /auth, /cloud, /health, /discovery (NOT /meta when scoped,
-   * so project-scoped meta routes can resolve their project).
+   * Environment RESOLUTION (hostname / x-environment-id / session /
+   * org-default / single-env-default → environment + driver) is owned by
+   * the host's resolver — the dispatcher no longer touches an environment
+   * registry. What stays here is pure URL parsing (the dispatcher's own
+   * routing convention): the scoped-path environment-id candidate and the
+   * cleaned route path, both UNVALIDATED.
    */
-  async resolveEnvironmentContext(context, path) {
-    const skipPaths = ["/cloud", "/health", "/discovery"];
-    if (skipPaths.some((p) => path.startsWith(p))) {
-      return;
-    }
-    if (!this.envRegistry) {
-      return;
-    }
-    const headers = context.request?.headers;
-    const getHeader = (name) => {
-      if (!headers) return void 0;
-      const h = headers;
-      if (typeof h.get === "function") {
-        const v = h.get(name);
-        return v == null ? void 0 : String(v);
-      }
-      const lower = name.toLowerCase();
-      for (const k of Object.keys(h)) {
-        if (k.toLowerCase() === lower) {
-          const v = h[k];
-          return Array.isArray(v) ? v[0] : v == null ? void 0 : String(v);
-        }
-      }
-      return void 0;
-    };
-    try {
-      const urlEnvironmentId = this.extractEnvironmentIdFromPath(path) ?? context.request?.params?.environmentId;
-      if (urlEnvironmentId) {
-        const driver = await this.envRegistry.resolveById(urlEnvironmentId);
-        if (driver) {
-          context.environmentId = urlEnvironmentId;
-          context.dataDriver = driver;
-          return;
-        }
-      }
-      const host = getHeader("host");
-      if (host) {
-        const hostname = host.split(":")[0];
-        const result = await this.envRegistry.resolveByHostname(hostname);
-        if (result) {
-          context.environmentId = result.environmentId;
-          context.dataDriver = result.driver;
-          return;
-        }
-      }
-      const envIdHeader = getHeader("x-environment-id");
-      if (envIdHeader) {
-        const driver = await this.envRegistry.resolveById(envIdHeader);
-        if (driver) {
-          context.environmentId = envIdHeader;
-          context.dataDriver = driver;
-          return;
-        }
-      }
-      try {
-        const authService = await this.getService(CoreServiceName.enum.auth);
-        const sessionData = await authService?.api?.getSession?.({
-          headers: context.request?.headers
-        });
-        const activeEnvironmentId = sessionData?.session?.activeEnvironmentId ?? sessionData?.session?.activeEnvironmentId;
-        if (activeEnvironmentId) {
-          const driver = await this.envRegistry.resolveById(activeEnvironmentId);
-          if (driver) {
-            context.environmentId = activeEnvironmentId;
-            context.dataDriver = driver;
-            return;
-          }
-        }
-        const activeOrganizationId = sessionData?.session?.activeOrganizationId;
-        if (activeOrganizationId) {
-          const qlService = await this.getObjectQLService();
-          const ql = qlService ?? await this.resolveService("objectql");
-          if (ql) {
-            let rows = await ql.find("sys_environment", {
-              where: {
-                organization_id: activeOrganizationId,
-                is_default: true
-              },
-              limit: 1
-            });
-            if (rows && rows.value) rows = rows.value;
-            if (Array.isArray(rows) && rows[0]) {
-              const defaultEnv = rows[0];
-              const driver = await this.envRegistry.resolveById(defaultEnv.id);
-              if (driver) {
-                context.environmentId = defaultEnv.id;
-                context.dataDriver = driver;
-                return;
-              }
-            }
-          }
-        }
-      } catch (sessionError) {
-        console.debug("[HttpDispatcher] Session resolution failed:", sessionError);
-      }
-      if (this.defaultProject?.environmentId || this.resolveDefaultProject()) {
-        const def = this.defaultProject;
-        const driver = await this.envRegistry.resolveById(def.environmentId);
-        if (driver) {
-          context.environmentId = def.environmentId;
-          context.dataDriver = driver;
-          return;
-        }
-      }
-    } catch (error) {
-      console.error("[HttpDispatcher] Environment resolution failed:", error);
-    }
+  prepareResolverHints(context, path) {
+    context.routePath = path;
+    const urlEnvironmentId = this.extractEnvironmentIdFromPath(path) ?? context.request?.params?.environmentId;
+    if (urlEnvironmentId) context.urlEnvironmentId = String(urlEnvironmentId);
   }
   /**
    * Check whether the authenticated user is a member of
@@ -3697,7 +3001,7 @@ var _HttpDispatcher = class _HttpDispatcher {
     if (!objectName) {
       return { handled: true, response: this.error("Object name required", 400) };
     }
-    if (!_context.dataDriver && this.envRegistry) {
+    if (!_context.dataDriver && this.kernelResolver) {
       return {
         handled: true,
         response: this.error("Project not resolved. Please specify X-Environment-Id header or ensure hostname maps to a project.", 428)
@@ -3976,17 +3280,19 @@ var _HttpDispatcher = class _HttpDispatcher {
               ...organizationId ? { organizationId } : {},
               ...body?.actor ? { actor: body.actor } : {}
             });
-            try {
-              const seedNames = (result?.published ?? []).filter((p) => p?.type === "seed").map((p) => p.name);
-              if (seedNames.length > 0) {
-                result.seedApplied = await this.applyPublishedSeeds(
-                  seedNames,
-                  organizationId,
-                  _context
-                );
+            if (result?.seedApplied === void 0) {
+              try {
+                const seedNames = (result?.published ?? []).filter((p) => p?.type === "seed").map((p) => p.name);
+                if (seedNames.length > 0) {
+                  result.seedApplied = await this.applyPublishedSeeds(
+                    seedNames,
+                    organizationId,
+                    _context
+                  );
+                }
+              } catch (e) {
+                result.seedApplied = { success: false, error: e?.message ?? "seed apply failed" };
               }
-            } catch (e) {
-              result.seedApplied = { success: false, error: e?.message ?? "seed apply failed" };
             }
             return { handled: true, response: this.success(result) };
           } catch (e) {
@@ -4596,9 +3902,9 @@ var _HttpDispatcher = class _HttpDispatcher {
       if (def?.environmentId) _context.environmentId = def.environmentId;
     }
     let projectQl = null;
-    if (this.kernelManager && _context.environmentId && _context.environmentId !== "platform") {
+    if (this.kernelResolver && _context.environmentId && _context.environmentId !== "platform") {
       try {
-        const projectKernel = await this.kernelManager.getOrCreate(_context.environmentId);
+        const projectKernel = await this.kernelResolver.resolveKernel(_context, this.defaultKernel);
         if (projectKernel) {
           this.kernel = projectKernel;
           if (typeof projectKernel.getServiceAsync === "function") {
@@ -4771,9 +4077,9 @@ var _HttpDispatcher = class _HttpDispatcher {
    */
   async dispatch(method, path, body, query, context, prefix) {
     let cleanPath = path.replace(/\/$/, "");
-    await this.resolveEnvironmentContext(context, cleanPath);
-    if (this.kernelManager && context.environmentId && context.environmentId !== "platform") {
-      this.kernel = await this.kernelManager.getOrCreate(context.environmentId);
+    this.prepareResolverHints(context, cleanPath);
+    if (this.kernelResolver) {
+      this.kernel = await this.kernelResolver.resolveKernel(context, this.defaultKernel) ?? this.defaultKernel;
     } else {
       this.kernel = this.defaultKernel;
     }
@@ -6209,1088 +5515,6 @@ var MiddlewareManager = class {
 // src/index.ts
 init_load_artifact_bundle();
 
-// src/cloud/cloud-url.ts
-var DEFAULT_CLOUD_URL = "https://cloud.objectos.ai";
-function resolveCloudUrl(explicit) {
-  const raw = (explicit ?? process.env.OS_CLOUD_URL ?? "").trim();
-  const lower = raw.toLowerCase();
-  if (lower === "off" || lower === "none" || lower === "local" || lower === "disabled") {
-    return "";
-  }
-  const picked = raw || DEFAULT_CLOUD_URL;
-  return picked.replace(/\/+$/, "");
-}
-
-// src/cloud/marketplace-public-url.ts
-function resolveMarketplacePublicBaseUrl(explicit) {
-  const raw = (explicit ?? process.env.OS_MARKETPLACE_PUBLIC_BASE_URL ?? "").trim();
-  const lower = raw.toLowerCase();
-  if (!raw || lower === "off" || lower === "none" || lower === "disabled" || lower === "false") {
-    return "";
-  }
-  return raw.replace(/\/+$/, "");
-}
-function publicMarketplaceKeyForApiPath(pathname) {
-  const prefix = "/api/v1/marketplace/packages";
-  if (pathname === prefix) return "packages.json";
-  if (!pathname.startsWith(`${prefix}/`)) return null;
-  const tail = pathname.slice(prefix.length + 1);
-  if (!tail) return null;
-  const parts = tail.split("/");
-  if (parts.length === 1) {
-    const id = decodeURIComponent(parts[0] ?? "");
-    if (!id) return null;
-    return `packages/${encodeURIComponent(id)}.json`;
-  }
-  if (parts.length === 4 && parts[1] === "versions" && parts[3] === "manifest") {
-    const id = decodeURIComponent(parts[0] ?? "");
-    const versionId = decodeURIComponent(parts[2] ?? "");
-    if (!id || !versionId) return null;
-    return `packages/${encodeURIComponent(id)}/versions/${encodeURIComponent(versionId)}/manifest.json`;
-  }
-  return null;
-}
-
-// src/cloud/marketplace-proxy-plugin.ts
-var MARKETPLACE_PREFIX = "/api/v1/marketplace";
-var DEFAULT_LRU_MAX = 200;
-var LIST_TTL_MS = 30 * 60 * 1e3;
-var PACKAGE_TTL_MS = 2 * 60 * 60 * 1e3;
-var VERSION_TTL_MS = 24 * 60 * 60 * 1e3;
-function ttlForPath(pathname) {
-  if (/\/packages\/[^/]+\/versions\//.test(pathname)) return VERSION_TTL_MS;
-  if (/\/packages\/[^/]+/.test(pathname)) return PACKAGE_TTL_MS;
-  return LIST_TTL_MS;
-}
-var LruTtlCache = class {
-  constructor(max) {
-    this.max = max;
-    this.map = /* @__PURE__ */ new Map();
-  }
-  get(key) {
-    const entry = this.map.get(key);
-    if (!entry) return void 0;
-    this.map.delete(key);
-    this.map.set(key, entry);
-    return entry;
-  }
-  set(key, entry) {
-    if (this.map.has(key)) this.map.delete(key);
-    this.map.set(key, entry);
-    while (this.map.size > this.max) {
-      const oldest = this.map.keys().next().value;
-      if (oldest === void 0) break;
-      this.map.delete(oldest);
-    }
-  }
-  clear() {
-    this.map.clear();
-  }
-};
-var MarketplaceProxyPlugin = class _MarketplaceProxyPlugin {
-  constructor(config = {}) {
-    this.name = "com.objectstack.runtime.marketplace-proxy";
-    this.version = "1.1.0";
-    this.init = async (_ctx) => {
-    };
-    this.start = async (ctx) => {
-      ctx.hook("kernel:ready", async () => {
-        let httpServer;
-        try {
-          httpServer = ctx.getService("http-server");
-        } catch {
-          ctx.logger?.warn?.("[MarketplaceProxyPlugin] http-server not available \u2014 marketplace routes not mounted");
-          return;
-        }
-        if (!httpServer || typeof httpServer.getRawApp !== "function") {
-          ctx.logger?.warn?.("[MarketplaceProxyPlugin] http-server missing getRawApp() \u2014 marketplace routes not mounted");
-          return;
-        }
-        const rawApp = httpServer.getRawApp();
-        const cloudUrl = this.cloudUrl;
-        const publicBaseUrl = this.publicBaseUrl;
-        const cache = this.cache;
-        if (publicBaseUrl) {
-          ctx.logger?.info?.(`[MarketplaceProxyPlugin] public R2 fast-path enabled \u2192 ${publicBaseUrl}`);
-        }
-        const handler = async (c, next) => {
-          if (!cloudUrl) {
-            return c.json({
-              success: false,
-              error: {
-                code: "marketplace_unavailable",
-                message: "No control-plane URL configured for this runtime (OS_CLOUD_URL)."
-              }
-            }, 503);
-          }
-          try {
-            const incomingUrl = new URL(c.req.url);
-            if (incomingUrl.pathname.startsWith(`${MARKETPLACE_PREFIX}/install-local`)) {
-              return next();
-            }
-            const method = String(c.req.method ?? "GET").toUpperCase();
-            if (publicBaseUrl && (method === "GET" || method === "HEAD")) {
-              const r2Resp = await tryPublicMarketplaceFetch(
-                publicBaseUrl,
-                incomingUrl,
-                method,
-                c.req.header("accept"),
-                ctx.logger
-              );
-              if (r2Resp) return r2Resp;
-            }
-            const target = `${cloudUrl}${incomingUrl.pathname}${incomingUrl.search}`;
-            if (method !== "GET" && method !== "HEAD") {
-              return next();
-            }
-            const accept = c.req.header("accept") ?? "application/json";
-            const acceptLang = c.req.header("accept-language") ?? "";
-            const cacheKey = `${incomingUrl.pathname}${incomingUrl.search}|al=${acceptLang}|a=${accept}`;
-            const reqCacheCtl = (c.req.header("cache-control") ?? "").toLowerCase();
-            const bypass = !cache || reqCacheCtl.includes("no-cache") || reqCacheCtl.includes("no-store");
-            const now = Date.now();
-            if (cache && !bypass) {
-              const hit = cache.get(cacheKey);
-              if (hit && hit.expiresAt > now) {
-                return buildCachedResponse(hit, method, "HIT");
-              }
-              if (hit) {
-                const revalHeaders = {
-                  "Accept": accept,
-                  "User-Agent": `objectos-marketplace-proxy/${_MarketplaceProxyPlugin.prototype.version ?? "1.0.0"}`
-                };
-                if (acceptLang) revalHeaders["Accept-Language"] = acceptLang;
-                if (hit.etag) revalHeaders["If-None-Match"] = hit.etag;
-                if (hit.lastModified) revalHeaders["If-Modified-Since"] = hit.lastModified;
-                const revalResp = await fetch(target, { method: "GET", headers: revalHeaders });
-                if (revalResp.status === 304) {
-                  hit.expiresAt = now + hit.ttlMs;
-                  const newEtag = revalResp.headers.get("etag");
-                  const newLm = revalResp.headers.get("last-modified");
-                  if (newEtag) hit.etag = newEtag;
-                  if (newLm) hit.lastModified = newLm;
-                  cache.set(cacheKey, hit);
-                  return buildCachedResponse(hit, method, "REVALIDATED");
-                }
-                return await consumeAndMaybeCache(revalResp, cacheKey, incomingUrl.pathname, method, cache);
-              }
-            }
-            const reqHeaders = {
-              // Strip the inbound Host header — fetch will set
-              // it to the cloud host. Forward only the
-              // identifying headers cloud might log.
-              "Accept": accept,
-              "User-Agent": `objectos-marketplace-proxy/${_MarketplaceProxyPlugin.prototype.version ?? "1.0.0"}`
-            };
-            if (acceptLang) reqHeaders["Accept-Language"] = acceptLang;
-            const resp = await fetch(target, { method: "GET", headers: reqHeaders });
-            if (bypass || !cache) {
-              return await passthroughResponse(resp, method, bypass ? "BYPASS" : "MISS");
-            }
-            return await consumeAndMaybeCache(resp, cacheKey, incomingUrl.pathname, method, cache);
-          } catch (err) {
-            const errObj = err instanceof Error ? err : new Error(err?.message ?? String(err));
-            ctx.logger?.error?.("[MarketplaceProxyPlugin] proxy failed", errObj);
-            return c.json({
-              success: false,
-              error: {
-                code: "marketplace_proxy_failed",
-                message: err?.message ?? String(err)
-              }
-            }, 502);
-          }
-        };
-        if (typeof rawApp.all === "function") {
-          rawApp.all(`${MARKETPLACE_PREFIX}/*`, handler);
-        } else {
-          for (const m of ["get", "head"]) {
-            try {
-              rawApp[m]?.(`${MARKETPLACE_PREFIX}/*`, handler);
-            } catch {
-            }
-          }
-        }
-        ctx.logger?.info?.(`[MarketplaceProxyPlugin] mounted at ${MARKETPLACE_PREFIX}/* \u2192 ${cloudUrl || "(unconfigured)"} (cache=${this.cache ? "on" : "off"})`);
-      });
-    };
-    this.cloudUrl = resolveCloudUrl(config.controlPlaneUrl);
-    this.publicBaseUrl = resolveMarketplacePublicBaseUrl(config.publicMarketplaceBaseUrl);
-    const envFlag = (process.env.OS_MARKETPLACE_CACHE ?? "").trim().toLowerCase();
-    const envDisabled = ["off", "false", "0", "no", "disable", "disabled"].includes(envFlag);
-    const disabled = config.cacheDisabled ?? envDisabled;
-    this.cache = disabled ? null : new LruTtlCache(Math.max(8, config.cacheMaxEntries ?? DEFAULT_LRU_MAX));
-  }
-};
-async function tryPublicMarketplaceFetch(publicBaseUrl, incomingUrl, method, acceptHeader, logger) {
-  const key = publicMarketplaceKeyForApiPath(incomingUrl.pathname);
-  if (!key) return null;
-  const target = `${publicBaseUrl}/${key}`;
-  let resp;
-  try {
-    resp = await fetch(target, {
-      method: "GET",
-      headers: {
-        "Accept": acceptHeader || "application/json",
-        "User-Agent": `objectos-marketplace-proxy/public-r2`
-      }
-    });
-  } catch (err) {
-    logger?.warn?.(`[MarketplaceProxyPlugin] public R2 fetch failed (${target}): ${err?.message ?? err}`);
-    return null;
-  }
-  if (resp.status === 404) return null;
-  if (!resp.ok) {
-    logger?.warn?.(`[MarketplaceProxyPlugin] public R2 ${target} returned ${resp.status} \u2014 falling back to cloud`);
-    return null;
-  }
-  const isList = key === "packages.json";
-  const hasFilters = isList && (incomingUrl.searchParams.has("q") || incomingUrl.searchParams.has("category") || incomingUrl.searchParams.has("limit") || incomingUrl.searchParams.has("offset"));
-  if (!hasFilters) {
-    const headers2 = new Headers();
-    const ct = resp.headers.get("content-type") ?? "application/json; charset=utf-8";
-    headers2.set("content-type", ct);
-    const cc = resp.headers.get("cache-control");
-    if (cc) headers2.set("cache-control", cc);
-    const etag = resp.headers.get("etag");
-    if (etag) headers2.set("etag", etag);
-    headers2.set("x-cache", "PUBLIC-R2");
-    const body2 = method === "HEAD" ? null : resp.body;
-    return new Response(body2, { status: 200, headers: headers2 });
-  }
-  let snapshot;
-  try {
-    snapshot = await resp.json();
-  } catch (err) {
-    logger?.warn?.(`[MarketplaceProxyPlugin] public R2 list snapshot parse failed: ${err?.message ?? err}`);
-    return null;
-  }
-  const items = Array.isArray(snapshot?.data?.items) ? snapshot.data.items : [];
-  const q = (incomingUrl.searchParams.get("q") ?? "").trim().toLowerCase();
-  const category = (incomingUrl.searchParams.get("category") ?? "").trim();
-  const limit = Math.min(Math.max(Number(incomingUrl.searchParams.get("limit") ?? 50), 1), 100);
-  const offset = Math.max(Number(incomingUrl.searchParams.get("offset") ?? 0), 0);
-  let filtered = items;
-  if (q) {
-    filtered = filtered.filter((r) => {
-      const dn = String(r?.display_name ?? "").toLowerCase();
-      const mid = String(r?.manifest_id ?? "").toLowerCase();
-      return dn.includes(q) || mid.includes(q);
-    });
-  }
-  if (category) {
-    filtered = filtered.filter((r) => String(r?.category ?? "") === category);
-  }
-  const total = filtered.length;
-  const page = filtered.slice(offset, offset + limit);
-  const body = JSON.stringify({ success: true, data: { items: page, total, limit, offset } });
-  const headers = new Headers({
-    "content-type": "application/json; charset=utf-8",
-    "cache-control": "public, max-age=30",
-    "x-cache": "PUBLIC-R2-FILTERED"
-  });
-  return new Response(method === "HEAD" ? null : body, { status: 200, headers });
-}
-var PASSTHROUGH_HEADERS = ["content-type", "cache-control", "etag", "last-modified", "vary"];
-function collectHeaders(src) {
-  const out = {};
-  for (const h of PASSTHROUGH_HEADERS) {
-    const v = src.headers.get(h);
-    if (v) out[h] = v;
-  }
-  return out;
-}
-function buildCachedResponse(entry, method, xCache) {
-  const headers = new Headers(entry.headers);
-  headers.set("X-Cache", xCache);
-  const ageSec = Math.max(0, Math.floor((entry.expiresAt - entry.ttlMs - Date.now()) / -1e3));
-  headers.set("Age", String(Math.max(0, ageSec)));
-  const body = method === "HEAD" ? null : entry.body;
-  return new Response(body, { status: entry.status, headers });
-}
-async function passthroughResponse(resp, method, xCache) {
-  const headers = new Headers(collectHeaders(resp));
-  headers.set("X-Cache", xCache);
-  if (method === "HEAD") {
-    try {
-      await resp.arrayBuffer();
-    } catch {
-    }
-    return new Response(null, { status: resp.status, headers });
-  }
-  const body = await resp.arrayBuffer();
-  return new Response(body, { status: resp.status, headers });
-}
-async function consumeAndMaybeCache(resp, key, pathname, method, cache) {
-  const body = await resp.arrayBuffer();
-  const headers = collectHeaders(resp);
-  if (resp.status >= 200 && resp.status < 300) {
-    const ttlMs = ttlForPath(pathname);
-    const entry = {
-      status: resp.status,
-      body,
-      headers,
-      etag: resp.headers.get("etag") ?? void 0,
-      lastModified: resp.headers.get("last-modified") ?? void 0,
-      expiresAt: Date.now() + ttlMs,
-      ttlMs
-    };
-    cache.set(key, entry);
-  }
-  const respHeaders = new Headers(headers);
-  respHeaders.set("X-Cache", "MISS");
-  const outBody = method === "HEAD" ? null : body;
-  return new Response(outBody, { status: resp.status, headers: respHeaders });
-}
-
-// src/cloud/marketplace-install-local-plugin.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync2, readdirSync, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join2, resolve } from "path";
-import { readEnvWithDeprecation as readEnvWithDeprecation3 } from "@objectstack/types";
-var ROUTE_BASE = "/api/v1/marketplace/install-local";
-var DEFAULT_DIR = ".objectstack/installed-packages";
-function safeFilename(manifestId) {
-  return manifestId.replace(/[^a-zA-Z0-9._-]/g, "_") + ".json";
-}
-var MarketplaceInstallLocalPlugin = class {
-  constructor(config = {}) {
-    this.name = "com.objectstack.runtime.marketplace-install-local";
-    this.version = "1.0.0";
-    this.init = async (_ctx) => {
-    };
-    this.start = async (ctx) => {
-      ctx.hook("kernel:ready", async () => {
-        await this.rehydrate(ctx);
-        let httpServer;
-        try {
-          httpServer = ctx.getService("http-server");
-        } catch {
-          ctx.logger?.warn?.("[MarketplaceInstallLocal] http-server not available \u2014 install endpoints not mounted");
-          return;
-        }
-        if (!httpServer || typeof httpServer.getRawApp !== "function") {
-          ctx.logger?.warn?.("[MarketplaceInstallLocal] http-server missing getRawApp() \u2014 install endpoints not mounted");
-          return;
-        }
-        const rawApp = httpServer.getRawApp();
-        const postHandler = async (c) => this.handleInstall(c, ctx);
-        const getHandler = async (c) => this.handleList(c);
-        const deleteHandler = async (c) => this.handleUninstall(c, ctx);
-        const reseedHandler = async (c) => this.handleReseed(c, ctx);
-        const purgeHandler = async (c) => this.handlePurge(c, ctx);
-        if (typeof rawApp.post === "function") rawApp.post(ROUTE_BASE, postHandler);
-        if (typeof rawApp.get === "function") rawApp.get(ROUTE_BASE, getHandler);
-        if (typeof rawApp.delete === "function") rawApp.delete(`${ROUTE_BASE}/:manifestId`, deleteHandler);
-        if (typeof rawApp.post === "function") {
-          rawApp.post(`${ROUTE_BASE}/:manifestId/reseed-sample-data`, reseedHandler);
-          rawApp.post(`${ROUTE_BASE}/:manifestId/purge-sample-data`, purgeHandler);
-        }
-        ctx.logger?.info?.(`[MarketplaceInstallLocal] mounted at ${ROUTE_BASE} (storage: ${this.storageDir})`);
-      });
-    };
-    /**
-     * Re-register every cached manifest with the kernel's manifest service.
-     * Safe to call on a kernel that already has the same manifest_id (the
-     * underlying ObjectQL registry overwrites by id, but we still warn so
-     * a developer can spot the dev-time clash between their config.ts and
-     * a marketplace package).
-     */
-    this.rehydrate = async (ctx) => {
-      const entries = this.readAll();
-      if (entries.length === 0) return;
-      let manifestService = null;
-      try {
-        manifestService = ctx.getService("manifest");
-      } catch {
-        ctx.logger?.warn?.("[MarketplaceInstallLocal] no `manifest` service \u2014 rehydrate skipped");
-        return;
-      }
-      for (const entry of entries) {
-        try {
-          manifestService.register(entry.manifest);
-          try {
-            const ql = ctx.getService("objectql");
-            if (ql && typeof ql.syncSchemas === "function") await ql.syncSchemas();
-          } catch {
-          }
-          await this.applySideEffects(ctx, entry.manifest, { seedNow: false });
-          ctx.logger?.info?.(`[MarketplaceInstallLocal] rehydrated ${entry.manifestId}@${entry.version}`);
-        } catch (err) {
-          ctx.logger?.error?.(`[MarketplaceInstallLocal] rehydrate failed for ${entry.manifestId}`, err instanceof Error ? err : new Error(String(err)));
-        }
-      }
-    };
-    this.handleInstall = async (c, ctx) => {
-      const userId = await this.requireAuthenticatedUser(c, ctx);
-      if (!userId) {
-        return c.json({ success: false, error: { code: "unauthorized", message: "Authentication required to install packages." } }, 401);
-      }
-      let body = {};
-      try {
-        body = await c.req.json();
-      } catch {
-      }
-      const inlineManifest = body?.manifest && typeof body.manifest === "object" ? body.manifest : null;
-      let manifest;
-      let resolvedVersionId;
-      let version;
-      let packageId;
-      if (inlineManifest) {
-        manifest = inlineManifest;
-        packageId = String(manifest.id ?? manifest.name ?? "").trim();
-        version = String(manifest.version ?? "unknown");
-        resolvedVersionId = String(body?.versionId ?? version);
-        if (!packageId) {
-          return c.json({ success: false, error: { code: "invalid_manifest", message: 'Inline manifest must have an "id" or "name".' } }, 400);
-        }
-      } else {
-        if (!this.cloudUrl) {
-          return c.json({ success: false, error: { code: "marketplace_unavailable", message: "OS_CLOUD_URL not configured." } }, 503);
-        }
-        packageId = String(body?.packageId ?? "").trim();
-        const versionId = String(body?.versionId ?? "latest").trim() || "latest";
-        if (!packageId) {
-          return c.json({ success: false, error: { code: "bad_request", message: "packageId is required." } }, 400);
-        }
-        let payload;
-        const publicBase = resolveMarketplacePublicBaseUrl();
-        const fetchAttempts = [];
-        if (publicBase) {
-          fetchAttempts.push({
-            label: "public-r2",
-            url: `${publicBase}/packages/${encodeURIComponent(packageId)}/versions/${encodeURIComponent(versionId)}/manifest.json`
-          });
-        }
-        fetchAttempts.push({
-          label: "cloud",
-          url: `${this.cloudUrl}/api/v1/marketplace/packages/${encodeURIComponent(packageId)}/versions/${encodeURIComponent(versionId)}/manifest`
-        });
-        let lastErrStatus = 0;
-        let lastErrText = "";
-        for (const attempt of fetchAttempts) {
-          try {
-            const resp = await fetch(attempt.url, { headers: { "Accept": "application/json" } });
-            if (!resp.ok) {
-              lastErrStatus = resp.status;
-              lastErrText = (await resp.text().catch(() => "")).slice(0, 200);
-              if (attempt.label === "public-r2" && resp.status === 404) {
-                ctx.logger?.info?.(`[MarketplaceInstallLocal] public-r2 miss for ${packageId}@${versionId}, falling back to cloud`);
-                continue;
-              }
-              if (attempt.label === "public-r2" && resp.status >= 500) {
-                ctx.logger?.warn?.(`[MarketplaceInstallLocal] public-r2 ${resp.status}, falling back to cloud`);
-                continue;
-              }
-              break;
-            }
-            payload = await resp.json();
-            lastErrStatus = 0;
-            break;
-          } catch (err) {
-            if (attempt.label === "public-r2") {
-              ctx.logger?.warn?.(`[MarketplaceInstallLocal] public-r2 fetch error: ${err?.message ?? err}, falling back to cloud`);
-              continue;
-            }
-            return c.json({
-              success: false,
-              error: { code: "cloud_fetch_failed", message: err?.message ?? String(err) }
-            }, 502);
-          }
-        }
-        if (!payload) {
-          return c.json({
-            success: false,
-            error: { code: "cloud_fetch_failed", message: `Cloud returned ${lastErrStatus}: ${lastErrText}` }
-          }, lastErrStatus === 404 ? 404 : 502);
-        }
-        const data = payload?.data ?? payload;
-        manifest = data?.manifest;
-        resolvedVersionId = String(data?.version_id ?? versionId);
-        version = String(data?.version ?? "unknown");
-      }
-      const manifestId = String(manifest?.id ?? manifest?.name ?? "");
-      if (!manifest || !manifestId) {
-        return c.json({ success: false, error: { code: "invalid_manifest", message: "Invalid manifest payload." } }, inlineManifest ? 400 : 502);
-      }
-      const conflict = this.findConflict(ctx, manifestId);
-      if (conflict === "user-code") {
-        return c.json({
-          success: false,
-          error: {
-            code: "manifest_conflict",
-            message: `manifest_id "${manifestId}" is already defined by this runtime's local code. Refusing to overwrite. Uninstall the local definition first.`
-          }
-        }, 409);
-      }
-      try {
-        const manifestService = ctx.getService("manifest");
-        manifestService.register(manifest);
-      } catch (err) {
-        if (inlineManifest) {
-          return c.json({
-            success: false,
-            error: { code: "register_failed", message: `Failed to register imported manifest: ${err?.message ?? err}` }
-          }, 422);
-        }
-        ctx.logger?.warn?.(`[MarketplaceInstallLocal] hot-register failed for ${manifestId} (will load on next restart): ${err?.message ?? err}`);
-      }
-      const entry = {
-        packageId,
-        versionId: resolvedVersionId,
-        manifestId,
-        version,
-        manifest,
-        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        installedBy: userId,
-        withSampleData: false
-      };
-      try {
-        mkdirSync4(this.storageDir, { recursive: true });
-        writeFileSync3(join2(this.storageDir, safeFilename(manifestId)), JSON.stringify(entry, null, 2), "utf8");
-      } catch (err) {
-        return c.json({
-          success: false,
-          error: { code: "storage_failed", message: `Failed to persist manifest: ${err?.message ?? err}` }
-        }, 500);
-      }
-      try {
-        const ql = ctx.getService("objectql");
-        if (ql && typeof ql.syncSchemas === "function") {
-          await ql.syncSchemas();
-          ctx.logger?.info?.(`[MarketplaceInstallLocal] syncSchemas() ran after registering ${manifestId}`);
-        }
-      } catch (err) {
-        ctx.logger?.warn?.(`[MarketplaceInstallLocal] syncSchemas failed for ${manifestId}: ${err?.message ?? err}`);
-      }
-      const seededSummary = await this.applySideEffects(ctx, manifest, { seedNow: true, c });
-      if (seededSummary.seeded.mode === "inline" && (seededSummary.seeded.inserted ?? 0) + (seededSummary.seeded.updated ?? 0) > 0) {
-        entry.withSampleData = true;
-        try {
-          writeFileSync3(join2(this.storageDir, safeFilename(manifestId)), JSON.stringify(entry, null, 2), "utf8");
-        } catch {
-        }
-      }
-      return c.json({
-        success: true,
-        data: {
-          manifestId,
-          version,
-          versionId: resolvedVersionId,
-          installedAt: entry.installedAt,
-          hotLoaded: true,
-          upgradedFrom: conflict === "marketplace" ? "previous-marketplace-version" : null,
-          translationsLoaded: seededSummary.translationsLoaded,
-          seeded: seededSummary.seeded,
-          note: "App is now available in this runtime. Refresh the console to see it in the app switcher."
-        }
-      }, 200);
-    };
-    this.handleList = async (c) => {
-      const entries = this.readAll();
-      return c.json({
-        success: true,
-        data: {
-          items: entries.map((e) => ({
-            packageId: e.packageId,
-            versionId: e.versionId,
-            manifestId: e.manifestId,
-            version: e.version,
-            installedAt: e.installedAt,
-            installedBy: e.installedBy,
-            withSampleData: e.withSampleData ?? false
-          })),
-          total: entries.length,
-          storageDir: this.storageDir
-        }
-      }, 200);
-    };
-    this.handleUninstall = async (c, ctx) => {
-      const userId = await this.requireAuthenticatedUser(c, ctx);
-      if (!userId) {
-        return c.json({ success: false, error: { code: "unauthorized", message: "Authentication required." } }, 401);
-      }
-      const manifestId = String(c.req.param?.("manifestId") ?? c.req.params?.manifestId ?? "").trim();
-      if (!manifestId) {
-        return c.json({ success: false, error: { code: "bad_request", message: "manifestId path param required." } }, 400);
-      }
-      const file = join2(this.storageDir, safeFilename(manifestId));
-      if (!existsSync3(file)) {
-        return c.json({ success: false, error: { code: "not_found", message: `No marketplace install for ${manifestId}.` } }, 404);
-      }
-      try {
-        unlinkSync(file);
-      } catch (err) {
-        return c.json({ success: false, error: { code: "storage_failed", message: err?.message ?? String(err) } }, 500);
-      }
-      ctx.logger?.info?.(`[MarketplaceInstallLocal] uninstalled ${manifestId} (cached manifest removed; restart runtime to unload from running kernel)`);
-      return c.json({
-        success: true,
-        data: {
-          manifestId,
-          note: "Cached manifest removed. The app remains loaded in the running kernel until the next restart (the kernel API does not support unregistering apps in-place)."
-        }
-      }, 200);
-    };
-    /**
-     * Detect whether `manifestId` is already known to the kernel and classify
-     * the source so we can refuse vs upgrade gracefully.
-     *
-     *   'none'         — fresh install
-     *   'marketplace'  — previously installed by this plugin (allow upgrade)
-     *   'user-code'    — defined by AppPlugin from objectstack.config.ts
-     *                    (refuse to avoid silently overwriting authored code)
-     */
-    this.findConflict = (ctx, manifestId) => {
-      if (existsSync3(join2(this.storageDir, safeFilename(manifestId)))) {
-        return "marketplace";
-      }
-      try {
-        const ql = ctx.getService("objectql");
-        const packages = ql?.registry?.getAllPackages?.() ?? [];
-        const hit = packages.find(
-          (p) => (p?.manifest?.id ?? p?.id ?? p?.manifest?.name) === manifestId
-        );
-        if (hit) return "user-code";
-      } catch {
-      }
-      return "none";
-    };
-    /**
-     * Pull a userId out of the request's better-auth session, if any.
-     * Returns null when there is no signed-in user. v1 does not check
-     * admin role — UI gating + the auth requirement is sufficient for
-     * dev / single-tenant runtimes. Stricter checks can be layered on
-     * via a middleware in cloud-hosted multi-tenant deployments.
-     */
-    /**
-     * POST /api/v1/marketplace/install-local/:manifestId/reseed-sample-data
-     *
-     * Re-runs SeedLoaderService against the cached manifest's `data` arrays.
-     * Idempotent (upsert by id). Useful when:
-     *   • The user installed an app and skipped sample data
-     *   • A purge was undone
-     *   • The user wants a clean baseline back after editing demo rows
-     *
-     * Multi-tenant: requires an active organization on the session (same
-     * rule as install seed path).
-     */
-    this.handleReseed = async (c, ctx) => {
-      const userId = await this.requireAuthenticatedUser(c, ctx);
-      if (!userId) {
-        return c.json({ success: false, error: { code: "unauthorized", message: "Authentication required." } }, 401);
-      }
-      const manifestId = String(c.req.param?.("manifestId") ?? c.req.params?.manifestId ?? "").trim();
-      if (!manifestId) {
-        return c.json({ success: false, error: { code: "bad_request", message: "manifestId path param required." } }, 400);
-      }
-      const file = join2(this.storageDir, safeFilename(manifestId));
-      if (!existsSync3(file)) {
-        return c.json({ success: false, error: { code: "not_found", message: `No marketplace install for ${manifestId}.` } }, 404);
-      }
-      let entry;
-      try {
-        entry = JSON.parse(readFileSync2(file, "utf8"));
-      } catch (err) {
-        return c.json({ success: false, error: { code: "storage_failed", message: `Failed to read manifest cache: ${err?.message ?? err}` } }, 500);
-      }
-      const summary = await this.applySideEffects(ctx, entry.manifest, { seedNow: true, c });
-      if (summary.seeded.mode === "skipped") {
-        return c.json({
-          success: false,
-          error: {
-            code: "reseed_skipped",
-            message: `Reseed did not run: ${summary.seeded.reason ?? "unknown reason"}`
-          }
-        }, 400);
-      }
-      try {
-        entry.withSampleData = true;
-        writeFileSync3(file, JSON.stringify(entry, null, 2), "utf8");
-      } catch {
-      }
-      return c.json({
-        success: true,
-        data: {
-          manifestId,
-          inserted: summary.seeded.inserted ?? 0,
-          updated: summary.seeded.updated ?? 0,
-          errors: summary.seeded.errors ?? 0,
-          withSampleData: true
-        }
-      }, 200);
-    };
-    /**
-     * POST /api/v1/marketplace/install-local/:manifestId/purge-sample-data
-     *
-     * Deletes every record whose id is declared in the cached manifest's
-     * seed datasets. Uses the `driver` service directly to bypass ACL /
-     * lifecycle hooks (same pattern as cloud purge). User-created records
-     * are never touched — only ids declared in the package's bundled
-     * datasets are removed. Already-deleted rows count as `skipped`.
-     */
-    this.handlePurge = async (c, ctx) => {
-      const userId = await this.requireAuthenticatedUser(c, ctx);
-      if (!userId) {
-        return c.json({ success: false, error: { code: "unauthorized", message: "Authentication required." } }, 401);
-      }
-      const manifestId = String(c.req.param?.("manifestId") ?? c.req.params?.manifestId ?? "").trim();
-      if (!manifestId) {
-        return c.json({ success: false, error: { code: "bad_request", message: "manifestId path param required." } }, 400);
-      }
-      const file = join2(this.storageDir, safeFilename(manifestId));
-      if (!existsSync3(file)) {
-        return c.json({ success: false, error: { code: "not_found", message: `No marketplace install for ${manifestId}.` } }, 404);
-      }
-      let entry;
-      try {
-        entry = JSON.parse(readFileSync2(file, "utf8"));
-      } catch (err) {
-        return c.json({ success: false, error: { code: "storage_failed", message: `Failed to read manifest cache: ${err?.message ?? err}` } }, 500);
-      }
-      const datasets = Array.isArray(entry.manifest?.data) ? entry.manifest.data.filter((d) => d && d.object && Array.isArray(d.records)) : [];
-      if (datasets.length === 0) {
-        return c.json({
-          success: false,
-          error: { code: "nothing_to_purge", message: "This package declares no seed datasets." }
-        }, 400);
-      }
-      let driver;
-      try {
-        driver = ctx.getService("driver");
-      } catch {
-      }
-      if (!driver || typeof driver.delete !== "function") {
-        return c.json({
-          success: false,
-          error: { code: "driver_missing", message: "driver service unavailable \u2014 cannot purge." }
-        }, 500);
-      }
-      let deleted = 0;
-      let skipped = 0;
-      let errors = 0;
-      for (const ds of datasets) {
-        const object = String(ds.object);
-        for (const rec of ds.records) {
-          const id = rec?.id;
-          if (id === void 0 || id === null || id === "") {
-            skipped++;
-            continue;
-          }
-          try {
-            const r = await driver.delete(object, id);
-            if (r === false || r === 0 || r?.deleted === 0) skipped++;
-            else deleted++;
-          } catch (err) {
-            const msg = String(err?.message ?? err);
-            if (/not.?found|no row/i.test(msg)) skipped++;
-            else {
-              errors++;
-              ctx.logger?.warn?.(`[MarketplaceInstallLocal] purge ${object}#${id}: ${msg}`);
-            }
-          }
-        }
-      }
-      try {
-        entry.withSampleData = false;
-        writeFileSync3(file, JSON.stringify(entry, null, 2), "utf8");
-      } catch {
-      }
-      ctx.logger?.info?.(`[MarketplaceInstallLocal] purged ${manifestId}: deleted=${deleted} skipped=${skipped} errors=${errors}`);
-      return c.json({
-        success: true,
-        data: { manifestId, deleted, skipped, errors, withSampleData: false }
-      }, 200);
-    };
-    /**
-     * Replicate the start-time side-effects that AppPlugin runs for
-     * statically-declared apps but the `manifest` service does NOT:
-     *
-     *   1. Load `manifest.translations` (array of `Record<locale, data>`)
-     *      into the i18n service — auto-creating an in-memory fallback if
-     *      none is registered, matching AppPlugin's behaviour.
-     *
-     *   2. Merge `manifest.data` (an array of seed datasets) into the
-     *      kernel's `seed-datasets` service so SecurityPlugin's per-org
-     *      replay middleware picks them up on every future
-     *      sys_organization insert.
-     *
-     *   3. When `seedNow=true`, also run the seed immediately so the user
-     *      sees demo data without having to create a new org:
-     *        • single-tenant: run SeedLoaderService inline (mirrors
-     *          AppPlugin single-tenant branch)
-     *        • multi-tenant: invoke `seed-replayer` for the caller's
-     *          active org (resolved from the request session)
-     *
-     * Errors are logged but never thrown — install succeeds even if
-     * post-register side-effects partially fail (the manifest itself is
-     * already registered + cached). Returns a small summary for the
-     * response envelope.
-     */
-    this.applySideEffects = async (ctx, manifest, opts) => {
-      const appId = String(manifest?.id ?? "unknown");
-      let translationsLoaded = 0;
-      let seedSummary = { mode: "skipped", reason: "no-datasets" };
-      try {
-        const bundles = [];
-        if (Array.isArray(manifest?.translations)) bundles.push(...manifest.translations);
-        if (Array.isArray(manifest?.i18n)) bundles.push(...manifest.i18n);
-        if (bundles.length > 0) {
-          let i18nService;
-          try {
-            i18nService = ctx.getService("i18n");
-          } catch {
-          }
-          if (!i18nService) {
-            try {
-              const mod = await import("@objectstack/core");
-              const createMemoryI18n = mod.createMemoryI18n;
-              if (typeof createMemoryI18n === "function") {
-                i18nService = createMemoryI18n();
-                ctx.registerService?.("i18n", i18nService);
-                ctx.logger?.info?.(`[MarketplaceInstallLocal] auto-registered in-memory i18n fallback for "${appId}"`);
-              }
-            } catch {
-            }
-          }
-          if (i18nService?.loadTranslations) {
-            for (const bundle of bundles) {
-              for (const [locale, data] of Object.entries(bundle)) {
-                if (data && typeof data === "object") {
-                  try {
-                    i18nService.loadTranslations(locale, data);
-                    translationsLoaded++;
-                  } catch (err) {
-                    ctx.logger?.warn?.(`[MarketplaceInstallLocal] failed to load ${appId} translations for ${locale}: ${err?.message ?? err}`);
-                  }
-                }
-              }
-            }
-            ctx.logger?.info?.(`[MarketplaceInstallLocal] loaded ${translationsLoaded} locale bundle(s) for ${appId}`);
-          }
-        }
-      } catch (err) {
-        ctx.logger?.warn?.(`[MarketplaceInstallLocal] i18n side-effect failed for ${appId}: ${err?.message ?? err}`);
-      }
-      const datasets = Array.isArray(manifest?.data) ? manifest.data.filter((d) => d && d.object && Array.isArray(d.records)) : [];
-      if (datasets.length > 0) {
-        try {
-          const kernel = ctx.kernel;
-          let existing = [];
-          try {
-            const v = kernel?.getService?.("seed-datasets");
-            if (Array.isArray(v)) existing = v;
-          } catch {
-          }
-          const merged = [...existing, ...datasets];
-          if (kernel?.registerService) kernel.registerService("seed-datasets", merged);
-          else ctx.registerService?.("seed-datasets", merged);
-          ctx.logger?.info?.(`[MarketplaceInstallLocal] merged ${datasets.length} seed dataset(s) into kernel (total: ${merged.length})`);
-        } catch (err) {
-          ctx.logger?.warn?.(`[MarketplaceInstallLocal] failed to merge seed-datasets: ${err?.message ?? err}`);
-        }
-      }
-      if (opts.seedNow && datasets.length > 0) {
-        const multiTenant = String(readEnvWithDeprecation3("OS_MULTI_ORG_ENABLED", "OS_MULTI_TENANT") ?? "false").toLowerCase() !== "false";
-        try {
-          const ql = ctx.getService("objectql");
-          let metadata;
-          try {
-            metadata = ctx.getService("metadata");
-          } catch {
-          }
-          if (!ql || !metadata) {
-            seedSummary = { mode: "skipped", reason: "objectql-or-metadata-missing" };
-          } else {
-            let organizationId;
-            if (multiTenant) {
-              const resolved = await this.resolveActiveOrgId(opts.c, ctx);
-              if (resolved) organizationId = resolved;
-              else {
-                seedSummary = { mode: "skipped", reason: "multi-tenant-no-active-org" };
-                ctx.logger?.warn?.("[MarketplaceInstallLocal] multi-tenant: no active org on request \u2014 data not seeded");
-              }
-            }
-            if (!multiTenant || organizationId) {
-              const [{ SeedLoaderService: SeedLoaderService2 }, { SeedLoaderRequestSchema }] = await Promise.all([
-                Promise.resolve().then(() => (init_seed_loader(), seed_loader_exports)),
-                import("@objectstack/spec/data")
-              ]);
-              const seedLoader = new SeedLoaderService2(ql, metadata, ctx.logger);
-              const request = SeedLoaderRequestSchema.parse({
-                datasets,
-                config: {
-                  defaultMode: "upsert",
-                  multiPass: true,
-                  ...organizationId ? { organizationId } : {}
-                }
-              });
-              const result = await seedLoader.load(request);
-              seedSummary = {
-                mode: "inline",
-                inserted: result.summary.totalInserted,
-                updated: result.summary.totalUpdated,
-                errors: result.errors.length
-              };
-              ctx.logger?.info?.(`[MarketplaceInstallLocal] inline seed for ${appId}${organizationId ? ` (org=${organizationId})` : ""}: inserted=${seedSummary.inserted} updated=${seedSummary.updated} errors=${seedSummary.errors}`);
-            }
-          }
-        } catch (err) {
-          seedSummary = { mode: "skipped", reason: `seed-error: ${err?.message ?? err}` };
-          ctx.logger?.warn?.(`[MarketplaceInstallLocal] seed run failed for ${appId}: ${err?.message ?? err}`);
-        }
-      }
-      return { translationsLoaded, seeded: seedSummary };
-    };
-    /**
-     * Best-effort active-org resolution. Reads the better-auth session
-     * (same path as requireAuthenticatedUser) and returns
-     * `session.activeOrganizationId`, falling back to the user's first
-     * org membership.
-     */
-    this.resolveActiveOrgId = async (c, ctx) => {
-      if (!c?.req?.raw?.headers) return null;
-      try {
-        const authService = ctx.getService("auth");
-        let api = authService?.api;
-        if (!api && typeof authService?.getApi === "function") api = await authService.getApi();
-        if (!api?.getSession) return null;
-        const session = await api.getSession({ headers: c.req.raw.headers });
-        const direct = session?.session?.activeOrganizationId ?? session?.activeOrganizationId ?? null;
-        if (direct) return String(direct);
-        const userId = session?.user?.id;
-        if (!userId) return null;
-        try {
-          const ql = ctx.getService("objectql");
-          if (ql?.find) {
-            const rows = await ql.find("sys_organization_member", { where: { user_id: userId }, limit: 1, context: { isSystem: true } });
-            const row = Array.isArray(rows) ? rows[0] : rows?.items?.[0] ?? null;
-            return row?.organization_id ? String(row.organization_id) : null;
-          }
-        } catch {
-        }
-      } catch {
-      }
-      return null;
-    };
-    this.requireAuthenticatedUser = async (c, ctx) => {
-      try {
-        const authService = ctx.getService("auth");
-        let api = authService?.api;
-        if (!api && typeof authService?.getApi === "function") {
-          api = await authService.getApi();
-        }
-        if (api?.getSession && c?.req?.raw?.headers) {
-          const session = await api.getSession({ headers: c.req.raw.headers });
-          const userId = session?.user?.id ?? null;
-          if (userId) return String(userId);
-        }
-      } catch {
-      }
-      const xUserId = c?.req?.header?.("x-user-id");
-      if (xUserId) return String(xUserId);
-      return null;
-    };
-    this.readAll = () => {
-      if (!existsSync3(this.storageDir)) return [];
-      const out = [];
-      for (const name of readdirSync(this.storageDir)) {
-        if (!name.endsWith(".json")) continue;
-        try {
-          const raw = readFileSync2(join2(this.storageDir, name), "utf8");
-          out.push(JSON.parse(raw));
-        } catch {
-        }
-      }
-      return out;
-    };
-    this.cloudUrl = resolveCloudUrl(config.controlPlaneUrl);
-    this.storageDir = config.storageDir ? resolve(config.storageDir) : resolve(process.cwd(), DEFAULT_DIR);
-  }
-};
-
-// src/cloud/runtime-config-plugin.ts
-var RuntimeConfigPlugin = class {
-  constructor(config = {}) {
-    this.name = "com.objectstack.runtime.runtime-config";
-    this.version = "1.0.0";
-    this.init = async (_ctx) => {
-    };
-    this.start = async (ctx) => {
-      ctx.hook("kernel:ready", async () => {
-        let httpServer;
-        try {
-          httpServer = ctx.getService("http-server");
-        } catch {
-          ctx.logger?.warn?.("[RuntimeConfigPlugin] http-server not available \u2014 runtime/config not mounted");
-          return;
-        }
-        if (!httpServer || typeof httpServer.getRawApp !== "function") {
-          ctx.logger?.warn?.("[RuntimeConfigPlugin] http-server missing getRawApp() \u2014 runtime/config not mounted");
-          return;
-        }
-        const rawApp = httpServer.getRawApp();
-        const features = {
-          installLocal: this.installLocal,
-          marketplace: true,
-          aiStudio: this.aiStudio
-        };
-        let envRegistry = null;
-        try {
-          envRegistry = ctx.getService("env-registry");
-        } catch {
-        }
-        const handler = async (c) => {
-          const rawHost = c.req.header("host") ?? "";
-          const host = rawHost.split(":")[0].toLowerCase().trim();
-          let defaultEnvironmentId;
-          let defaultOrgId;
-          let resolvedSingleEnv = this.singleEnvironment;
-          const resolveFn = typeof envRegistry?.resolveByHostname === "function" ? envRegistry.resolveByHostname.bind(envRegistry) : typeof envRegistry?.resolveHostname === "function" ? envRegistry.resolveHostname.bind(envRegistry) : null;
-          if (resolveFn && host) {
-            try {
-              const resolved = await resolveFn(host);
-              if (resolved?.environmentId) {
-                defaultEnvironmentId = String(resolved.environmentId);
-                const orgId = resolved.organizationId ?? resolved.organization_id;
-                if (orgId) defaultOrgId = String(orgId);
-                resolvedSingleEnv = true;
-              }
-            } catch {
-            }
-          }
-          return c.json({
-            cloudUrl: this.cloudUrl,
-            singleEnvironment: resolvedSingleEnv,
-            defaultOrgId,
-            defaultEnvironmentId,
-            features,
-            branding: {
-              productName: this.productName,
-              productShortName: this.productShortName
-            }
-          });
-        };
-        rawApp.get("/api/v1/runtime/config", handler);
-        rawApp.get("/api/v1/studio/runtime-config", handler);
-        ctx.logger?.info?.("[RuntimeConfigPlugin] mounted /api/v1/runtime/config", {
-          cloudUrl: this.cloudUrl || "(empty)",
-          installLocal: this.installLocal,
-          perHostEnvResolution: !!envRegistry
-        });
-      });
-    };
-    this.destroy = async () => {
-    };
-    this.cloudUrl = config.controlPlaneUrl === "" ? "" : resolveCloudUrl(config.controlPlaneUrl) ?? "";
-    this.installLocal = !!config.installLocal;
-    this.aiStudio = config.aiStudio !== false;
-    this.singleEnvironment = !!config.singleEnvironment;
-    const envName = (typeof process !== "undefined" ? process.env?.OS_PRODUCT_NAME : void 0)?.trim();
-    const envShort = (typeof process !== "undefined" ? process.env?.OS_PRODUCT_SHORT_NAME : void 0)?.trim();
-    this.productName = (config.productName ?? envName ?? "ObjectOS").trim() || "ObjectOS";
-    this.productShortName = (config.productShortName ?? envShort ?? this.productName).trim() || this.productName;
-  }
-};
-
 // src/sandbox/script-runner.ts
 var UnimplementedScriptRunner = class {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -7321,10 +5545,9 @@ import {
   createRestApiPlugin
 } from "@objectstack/rest";
 export * from "@objectstack/core";
-import { readEnvWithDeprecation as readEnvWithDeprecation4, _resetEnvDeprecationWarnings } from "@objectstack/types";
+import { readEnvWithDeprecation as readEnvWithDeprecation3, _resetEnvDeprecationWarnings } from "@objectstack/types";
 export {
   AppPlugin,
-  DEFAULT_CLOUD_URL,
   DEFAULT_RATE_LIMITS,
   DriverPlugin,
   ExternalValidationPlugin,
@@ -7332,8 +5555,6 @@ export {
   HttpServer,
   InMemoryErrorReporter,
   InMemoryMetricsRegistry,
-  MarketplaceInstallLocalPlugin,
-  MarketplaceProxyPlugin,
   MiddlewareManager,
   NoopErrorReporter,
   NoopMetricsRegistry,
@@ -7348,7 +5569,6 @@ export {
   RouteGroupBuilder,
   RouteManager,
   Runtime,
-  RuntimeConfigPlugin,
   SYSTEM_ENVIRONMENT_ID,
   SandboxError,
   SeedLoaderService,
@@ -7374,8 +5594,7 @@ export {
   mergeRuntimeModule,
   parseTraceparent,
   readArtifactSource,
-  readEnvWithDeprecation4 as readEnvWithDeprecation,
-  resolveCloudUrl,
+  readEnvWithDeprecation3 as readEnvWithDeprecation,
   resolveDefaultArtifactPath,
   resolveErrorReporter,
   resolveMetrics,