@objectstack/metadata-protocol 11.1.0

package/dist/chunk-JRNTUZG6.cjs

@@ -0,0 +1,639 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/seed-loader.ts
+var _data = require('@objectstack/spec/data');
+var _formula = require('@objectstack/formula');
+var DEFAULT_EXTERNAL_ID_FIELD = "name";
+var _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 = [];
+    this.fallbackOrgId = config.organizationId == null ? await this.resolveSoleOrganizationId() : void 0;
+    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.type === "user") && 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 = _data.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,
+      // `id: null` is a legitimate seed-time state (the owning admin does not
+      // exist yet) that the formula EvalContext's `user.id: string` type does
+      // not yet model — cast the fallback so `os.user.id` evaluates to null.
+      user: _nullishCoalesce(_optionalChain([seedIdentity, 'optionalAccess', _ => _.user]), () => ( { id: null })),
+      // Fall back to the per-tenant organizationId so `os.org.id` resolves
+      // during per-org replay even without an explicit identity.org.
+      org: _nullishCoalesce(_optionalChain([seedIdentity, 'optionalAccess', _2 => _2.org]), () => ( (config.organizationId ? { id: config.organizationId } : void 0))),
+      env: config.env
+    };
+    for (let i = 0; i < dataset.records.length; i++) {
+      const seedResult = _formula.resolveSeedRecord.call(void 0, 
+        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}. \`os.user.id\` resolves to null at seed time (the owning admin does not exist yet) and owner-style fields are assigned by the first-admin handoff \u2014 so a required, non-owner field must not depend on it. Provide a literal value or make the field optional.`
+        };
+        errors.push(error);
+        allErrors.push(error);
+        this.logger.warn(`[SeedLoader] ${error.message}`);
+        continue;
+      }
+      const record = { ...seedResult.value };
+      const tenantOrg = _nullishCoalesce(config.organizationId, () => ( (/^(sys_|cloud_|ai_)/.test(objectName) ? void 0 : this.fallbackOrgId)));
+      if (tenantOrg && record["organization_id"] == null) {
+        record["organization_id"] = tenantOrg;
+      }
+      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 = _optionalChain([targetMap, 'optionalAccess', _3 => _3.get, 'call', _4 => _4(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(_nullishCoalesce(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 (!_optionalChain([targetMap2, 'optionalAccess', _5 => _5.has, 'call', _6 => _6(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(_nullishCoalesce(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: _nullishCoalesce(record[externalId], () => ( null)),
+            recordIndex: i,
+            message: `Failed to write ${objectName} record #${i} (${externalId}=${String(_nullishCoalesce(record[externalId], () => ( "")))}): ${err.message}`
+          };
+          errors.push(error);
+          allErrors.push(error);
+          this.logger.warn(`[SeedLoader] ${error.message}`, { recordIndex: i });
+        }
+      } else {
+        const externalIdValue = String(_nullishCoalesce(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
+  // ==========================================================================
+  /**
+   * Best-effort resolve the tenant's SOLE organization id — used to stamp
+   * business seed rows when the caller pinned no `config.organizationId` (an
+   * in-process publish has no active user session). A fresh env has exactly one
+   * org, so its seeds should carry it like a normal write instead of landing
+   * org-less (→ invisible under strict org-scoping). Returns undefined when
+   * there are zero or several orgs (genuinely ambiguous — keep the historical
+   * global/cross-tenant NULL) or when `sys_organization` is absent.
+   */
+  async resolveSoleOrganizationId() {
+    try {
+      const rows = await this.engine.find("sys_organization", {
+        fields: ["id"],
+        limit: 2,
+        context: { isSystem: true }
+      });
+      if (Array.isArray(rows) && rows.length === 1) {
+        const id = _nullishCoalesce(_optionalChain([rows, 'access', _7 => _7[0], 'optionalAccess', _8 => _8.id]), () => ( _optionalChain([rows, 'access', _9 => _9[0], 'optionalAccess', _10 => _10._id])));
+        return id ? String(id) : void 0;
+      }
+    } catch (e) {
+    }
+    return void 0;
+  }
+  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);
+      }
+      if (targetField !== "id") {
+        const byId = { id: value };
+        if (organizationId) byId.organization_id = organizationId;
+        const idMatch = await this.engine.find(targetObject, {
+          where: byId,
+          fields: ["id"],
+          limit: 1,
+          context: { isSystem: true }
+        });
+        if (idMatch && idMatch.length > 0) {
+          return String(idMatch[0].id || idMatch[0]._id);
+        }
+      }
+    } catch (e2) {
+    }
+    return null;
+  }
+  async resolveDeferredUpdates(deferredUpdates, insertedRecords, allResults, allErrors, organizationId) {
+    for (const deferred of deferredUpdates) {
+      const targetMap = insertedRecords.get(deferred.targetObject);
+      let resolvedId = _optionalChain([targetMap, 'optionalAccess', _11 => _11.get, 'call', _12 => _12(String(deferred.attemptedValue))]);
+      if (!resolvedId) {
+        resolvedId = await _asyncNullishCoalesce(await this.resolveFromDatabase(
+          deferred.targetObject,
+          deferred.targetField,
+          deferred.attemptedValue,
+          organizationId
+        ), async () => ( void 0));
+      }
+      if (resolvedId) {
+        const objectRecordMap = insertedRecords.get(deferred.objectName);
+        const recordId = _optionalChain([objectRecordMap, 'optionalAccess', _13 => _13.get, 'call', _14 => _14(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 = _optionalChain([existingRecords, 'optionalAccess', _15 => _15.get, 'call', _16 => _16(String(_nullishCoalesce(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 = _nullishCoalesce(orderMap.get(a.object), () => ( Number.MAX_SAFE_INTEGER));
+      const orderB = _nullishCoalesce(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(_nullishCoalesce(record[externalId], () => ( "")));
+        if (key) {
+          map.set(key, record);
+        }
+      }
+    } catch (e3) {
+    }
+    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 } };
+var SeedLoaderService = _SeedLoaderService;
+
+
+
+exports.SeedLoaderService = SeedLoaderService;
+//# sourceMappingURL=chunk-JRNTUZG6.cjs.map