on-zero 0.7.10 → 0.8.0

package/dist/cjs/generate-layout.native.js

@@ -0,0 +1,1275 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var generate_layout_exports = {};
+__export(generate_layout_exports, {
+  discoverDataLayout: () => discoverDataLayout,
+  namespaceImportPath: () => namespaceImportPath
+});
+module.exports = __toCommonJS(generate_layout_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var isSourceFile = function isSourceFile2(name) {
+  return name.endsWith(".ts") && !name.endsWith(".d.ts") && !name.endsWith(".test.ts") && !name.endsWith(".spec.ts");
+};
+var toImportPath = function toImportPath2(baseDir, path) {
+  return (0, import_path.relative)(baseDir, path).split(import_path.sep).join("/").replace(/\.ts$/, "");
+};
+var isWithin = function isWithin2(root, path) {
+  var child = (0, import_path.relative)(root, path);
+  return child === "" || child !== ".." && !child.startsWith(`..${import_path.sep}`);
+};
+function propertyName(ts, name) {
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+    return name.text;
+  }
+  return null;
+}
+function readDataConfig(ts, baseDir, configPath) {
+  var path = configPath ? (0, import_path.resolve)(configPath) : (0, import_path.resolve)(baseDir, "on-zero.config.ts");
+  if (!(0, import_fs.existsSync)(path)) {
+    if (configPath) throw new Error(`[on-zero] config file does not exist: ${path}`);
+    return null;
+  }
+  if ((0, import_path.dirname)(path) !== baseDir) {
+    throw new Error(`[on-zero] ${path} must be at the data root ${baseDir}`);
+  }
+  var source = ts.createSourceFile(path, (0, import_fs.readFileSync)(path, "utf8"), ts.ScriptTarget.Latest, true);
+  if (hasParseErrors(source)) throw new Error(`[on-zero] unable to parse ${path}`);
+  var config = null;
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = source.statements[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var statement = _step.value;
+      if (!ts.isExportAssignment(statement) || statement.isExportEquals) continue;
+      var call = statement.expression;
+      if (!ts.isCallExpression(call) || call.expression.getText(source) !== "defineConfig") {
+        continue;
+      }
+      var value = call.arguments[0];
+      if (value && ts.isObjectLiteralExpression(value)) config = value;
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  if (!config) {
+    throw new Error(`[on-zero] ${path} must default export defineConfig({ instances: { ... } })`);
+  }
+  var rootOptions = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion1 = true,
+    _didIteratorError1 = false,
+    _iteratorError1 = void 0;
+  try {
+    for (var _iterator1 = config.properties[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+      var option = _step1.value;
+      if (!ts.isPropertyAssignment(option)) {
+        throw new Error(`[on-zero] ${path} options must use explicit property assignments`);
+      }
+      var name = propertyName(ts, option.name);
+      if (!name) throw new Error(`[on-zero] ${path} has an unsupported option name`);
+      if (rootOptions.has(name)) throw new Error(`[on-zero] ${path} repeats option '${name}'`);
+      rootOptions.set(name, option.initializer);
+    }
+  } catch (err) {
+    _didIteratorError1 = true;
+    _iteratorError1 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+        _iterator1.return();
+      }
+    } finally {
+      if (_didIteratorError1) {
+        throw _iteratorError1;
+      }
+    }
+  }
+  var _iteratorNormalCompletion2 = true,
+    _didIteratorError2 = false,
+    _iteratorError2 = void 0;
+  try {
+    for (var _iterator2 = rootOptions.keys()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+      var name1 = _step2.value;
+      if (name1 !== "instances") throw new Error(`[on-zero] ${path} has unknown option '${name1}'`);
+    }
+  } catch (err) {
+    _didIteratorError2 = true;
+    _iteratorError2 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+        _iterator2.return();
+      }
+    } finally {
+      if (_didIteratorError2) {
+        throw _iteratorError2;
+      }
+    }
+  }
+  var instancesNode = rootOptions.get("instances");
+  if (!instancesNode || !ts.isObjectLiteralExpression(instancesNode)) {
+    throw new Error(`[on-zero] ${path} must declare a non-empty instances object`);
+  }
+  var instances = [];
+  var _iteratorNormalCompletion3 = true,
+    _didIteratorError3 = false,
+    _iteratorError3 = void 0;
+  try {
+    var _loop = function () {
+      var property = _step3.value;
+      if (!ts.isPropertyAssignment(property)) {
+        throw new Error(`[on-zero] ${path} instances must use explicit property assignments`);
+      }
+      var name2 = propertyName(ts, property.name);
+      if (!name2) throw new Error(`[on-zero] ${path} has an unsupported instance name`);
+      if (!ts.isObjectLiteralExpression(property.initializer)) {
+        throw new Error(`[on-zero] instance '${name2}' must be an object`);
+      }
+      if (instances.some(function (instance) {
+        return instance.name === name2;
+      })) {
+        throw new Error(`[on-zero] duplicate instance name '${name2}'`);
+      }
+      var dir = (0, import_path.resolve)((0, import_path.dirname)(path), name2);
+      var scope = null;
+      var supportTables = [];
+      var seen = /* @__PURE__ */new Set();
+      var _iteratorNormalCompletion5 = true,
+        _didIteratorError5 = false,
+        _iteratorError5 = void 0;
+      try {
+        for (var _iterator5 = property.initializer.properties[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+          var option2 = _step5.value;
+          if (!ts.isPropertyAssignment(option2)) {
+            throw new Error(`[on-zero] instance '${name2}' options must be assignments`);
+          }
+          var optionName = propertyName(ts, option2.name);
+          if (!optionName) throw new Error(`[on-zero] instance '${name2}' has an invalid option`);
+          if (seen.has(optionName)) {
+            throw new Error(`[on-zero] instance '${name2}' repeats option '${optionName}'`);
+          }
+          seen.add(optionName);
+          if (optionName === "dir") {
+            if (!ts.isStringLiteral(option2.initializer)) {
+              throw new Error(`[on-zero] instance '${name2}' dir must be a string literal`);
+            }
+            if (option2.initializer.text.startsWith("/")) {
+              throw new Error(`[on-zero] instance '${name2}' dir must be relative to ${path}`);
+            }
+            dir = (0, import_path.resolve)((0, import_path.dirname)(path), option2.initializer.text);
+            continue;
+          }
+          if (optionName === "scope") {
+            if (!ts.isStringLiteral(option2.initializer)) {
+              throw new Error(`[on-zero] instance '${name2}' scope must be a string literal`);
+            }
+            if (!option2.initializer.text) {
+              throw new Error(`[on-zero] instance '${name2}' scope cannot be empty`);
+            }
+            scope = option2.initializer.text;
+            continue;
+          }
+          if (optionName === "supportTables") {
+            if (!ts.isArrayLiteralExpression(option2.initializer)) {
+              throw new Error(`[on-zero] instance '${name2}' supportTables must be an array`);
+            }
+            var _iteratorNormalCompletion12 = true,
+              _didIteratorError12 = false,
+              _iteratorError12 = void 0;
+            try {
+              for (var _iterator12 = option2.initializer.elements[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+                var table = _step12.value;
+                if (!ts.isStringLiteral(table)) {
+                  throw new Error(`[on-zero] instance '${name2}' supportTables must contain string literals`);
+                }
+                if (!table.text) {
+                  throw new Error(`[on-zero] instance '${name2}' supportTables cannot contain an empty table name`);
+                }
+                supportTables.push(table.text);
+              }
+            } catch (err) {
+              _didIteratorError12 = true;
+              _iteratorError12 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+                  _iterator12.return();
+                }
+              } finally {
+                if (_didIteratorError12) {
+                  throw _iteratorError12;
+                }
+              }
+            }
+            continue;
+          }
+          throw new Error(`[on-zero] instance '${name2}' has unknown option '${optionName}'`);
+        }
+      } catch (err) {
+        _didIteratorError5 = true;
+        _iteratorError5 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+            _iterator5.return();
+          }
+        } finally {
+          if (_didIteratorError5) {
+            throw _iteratorError5;
+          }
+        }
+      }
+      if (!(0, import_fs.existsSync)(dir) || !(0, import_fs.statSync)(dir).isDirectory()) {
+        throw new Error(`[on-zero] instance '${name2}' directory does not exist: ${dir}`);
+      }
+      instances.push({
+        name: name2,
+        dir,
+        scope,
+        supportTables
+      });
+    };
+    for (var _iterator3 = instancesNode.properties[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) _loop();
+  } catch (err) {
+    _didIteratorError3 = true;
+    _iteratorError3 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+        _iterator3.return();
+      }
+    } finally {
+      if (_didIteratorError3) {
+        throw _iteratorError3;
+      }
+    }
+  }
+  if (instances.length === 0) {
+    throw new Error(`[on-zero] ${path} must declare at least one instance`);
+  }
+  var _iteratorNormalCompletion4 = true,
+    _didIteratorError4 = false,
+    _iteratorError4 = void 0;
+  try {
+    var _loop1 = function () {
+      var instance = _step4.value;
+      var duplicate = instances.find(function (candidate) {
+        return candidate !== instance && candidate.dir === instance.dir;
+      });
+      if (duplicate) {
+        throw new Error(`[on-zero] instances '${instance.name}' and '${duplicate.name}' resolve to the same directory: ${instance.dir}`);
+      }
+    };
+    for (var _iterator4 = instances[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) _loop1();
+  } catch (err) {
+    _didIteratorError4 = true;
+    _iteratorError4 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+        _iterator4.return();
+      }
+    } finally {
+      if (_didIteratorError4) {
+        throw _iteratorError4;
+      }
+    }
+  }
+  return {
+    path,
+    instances
+  };
+}
+function hasParseErrors(source) {
+  var _source_parseDiagnostics;
+  return Boolean((_source_parseDiagnostics = source.parseDiagnostics) === null || _source_parseDiagnostics === void 0 ? void 0 : _source_parseDiagnostics.length);
+}
+function hasNamespaceExports(ts, baseDir, path) {
+  var source = ts.createSourceFile(path, (0, import_fs.readFileSync)(path, "utf8"), ts.ScriptTarget.Latest, true);
+  if (hasParseErrors(source)) {
+    var displayPath = (0, import_path.relative)((0, import_path.dirname)(baseDir), path).split(import_path.sep).join("/");
+    console.warn(`[on-zero] ignoring ${displayPath}: no recognized data exports`);
+    return false;
+  }
+  var functions = /* @__PURE__ */new Map();
+  var exported = /* @__PURE__ */new Set();
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = source.statements[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var statement = _step.value;
+      if (ts.isVariableStatement(statement)) {
+        var _statement_modifiers;
+        var isExported = (_statement_modifiers = statement.modifiers) === null || _statement_modifiers === void 0 ? void 0 : _statement_modifiers.some(function (modifier) {
+          return modifier.kind === ts.SyntaxKind.ExportKeyword;
+        });
+        var _iteratorNormalCompletion1 = true,
+          _didIteratorError1 = false,
+          _iteratorError1 = void 0;
+        try {
+          for (var _iterator1 = statement.declarationList.declarations[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+            var declaration = _step1.value;
+            if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+            var name = declaration.name.text;
+            var initializer = declaration.initializer;
+            if (isExported && ts.isCallExpression(initializer)) {
+              var initializerText = initializer.getText(source);
+              if (name === "mutate" && initializerText.startsWith("mutations(") || name === "where" && initializerText.startsWith("serverWhere(") || name === "schema" && initializerText.startsWith("table(")) {
+                return true;
+              }
+            }
+            if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) {
+              functions.set(name, initializer.body);
+              if (isExported) exported.add(name);
+            }
+          }
+        } catch (err) {
+          _didIteratorError1 = true;
+          _iteratorError1 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+              _iterator1.return();
+            }
+          } finally {
+            if (_didIteratorError1) {
+              throw _iteratorError1;
+            }
+          }
+        }
+        continue;
+      }
+      if (ts.isFunctionDeclaration(statement) && statement.name && statement.body) {
+        var _statement_modifiers1;
+        functions.set(statement.name.text, statement.body);
+        if ((_statement_modifiers1 = statement.modifiers) === null || _statement_modifiers1 === void 0 ? void 0 : _statement_modifiers1.some(function (modifier) {
+          return modifier.kind === ts.SyntaxKind.ExportKeyword;
+        })) {
+          exported.add(statement.name.text);
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var visiting = /* @__PURE__ */new Set();
+  var reachesQuery = function reachesQuery1(node) {
+    if (ts.isPropertyAccessExpression(node)) {
+      if (ts.isIdentifier(node.expression) && node.expression.text === "zql") return true;
+      if (ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "query") return true;
+    }
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      var name2 = node.expression.text;
+      var helper = functions.get(name2);
+      if (helper && !visiting.has(name2)) {
+        visiting.add(name2);
+        var found = reachesQuery(helper);
+        visiting.delete(name2);
+        if (found) return true;
+      }
+    }
+    var found1 = false;
+    ts.forEachChild(node, function (child) {
+      if (!found1 && reachesQuery(child)) found1 = true;
+    });
+    return found1;
+  };
+  return [...exported].some(function (name2) {
+    return reachesQuery(functions.get(name2));
+  });
+}
+function discoverNamespaces(ts, baseDir, instance, instanceDirs) {
+  var namespaces = [];
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = (0, import_fs.readdirSync)(instance.dir, {
+        withFileTypes: true
+      }).sort(function (a, b) {
+        return a.name.localeCompare(b.name);
+      })[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var entry = _step.value;
+      if (entry.isFile()) {
+        if (!isSourceFile(entry.name) || entry.name === "on-zero.config.ts") continue;
+        var path = (0, import_path.resolve)(instance.dir, entry.name);
+        if (!hasNamespaceExports(ts, baseDir, path)) continue;
+        var name = (0, import_path.basename)(entry.name, ".ts");
+        namespaces.push({
+          name,
+          instance: instance.name,
+          queryPath: path,
+          modelPath: path,
+          sourcePaths: [path]
+        });
+        continue;
+      }
+      if (!entry.isDirectory()) continue;
+      var folder = (0, import_path.resolve)(instance.dir, entry.name);
+      if (entry.name === "generated" || instanceDirs.has(folder)) continue;
+      var queryPath = (0, import_path.resolve)(folder, "queries.ts");
+      var modelPath = (0, import_path.resolve)(folder, "mutations.ts");
+      var hasQueries = (0, import_fs.existsSync)(queryPath);
+      var hasMutations = (0, import_fs.existsSync)(modelPath);
+      if (!hasQueries && !hasMutations) {
+        if (["models", "mutations", "queries"].includes(entry.name) && (0, import_fs.readdirSync)(folder).some(isSourceFile)) {
+          throw new Error(`[on-zero] ${folder} uses the removed top-level ${entry.name}/ layout; move each namespace to <name>.ts or <name>/queries.ts + mutations.ts`);
+        }
+        continue;
+      }
+      namespaces.push({
+        name: entry.name,
+        instance: instance.name,
+        queryPath: hasQueries ? queryPath : null,
+        modelPath: hasMutations ? modelPath : null,
+        sourcePaths: [hasQueries && queryPath, hasMutations && modelPath].filter(function (path2) {
+          return Boolean(path2);
+        })
+      });
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return namespaces;
+}
+function metadataPaths(baseDir) {
+  var paths = [];
+  var relations = (0, import_path.resolve)(baseDir, "relations.ts");
+  if ((0, import_fs.existsSync)(relations)) paths.push(relations);
+  var databaseDir = (0, import_path.resolve)((0, import_path.dirname)(baseDir), "database");
+  if (!(0, import_fs.existsSync)(databaseDir)) return paths;
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = (0, import_fs.readdirSync)(databaseDir, {
+        withFileTypes: true
+      })[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var entry = _step.value;
+      if (!entry.isFile() || !isSourceFile(entry.name)) continue;
+      if (entry.name === "relations.ts" || entry.name === "zeroSchemaInput.ts" || entry.name.startsWith("schema")) {
+        paths.push((0, import_path.resolve)(databaseDir, entry.name));
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return paths.sort();
+}
+function relationTargets(ts, paths) {
+  var relations = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    var _loop = function () {
+      var path = _step.value;
+      var source = ts.createSourceFile(path, (0, import_fs.readFileSync)(path, "utf8"), ts.ScriptTarget.Latest, true);
+      var visit = function visit1(node) {
+        if (!ts.isCallExpression(node) || node.expression.getText(source) !== "defineRelations") {
+          ts.forEachChild(node, visit);
+          return;
+        }
+        var factory = node.arguments[1];
+        if (!factory || !ts.isArrowFunction(factory) && !ts.isFunctionExpression(factory)) return;
+        var body = ts.isParenthesizedExpression(factory.body) ? factory.body.expression : factory.body;
+        if (!ts.isObjectLiteralExpression(body)) return;
+        var _iteratorNormalCompletion2 = true,
+          _didIteratorError2 = false,
+          _iteratorError2 = void 0;
+        try {
+          for (var _iterator2 = body.properties[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            var tableProperty = _step2.value;
+            var _relations_get;
+            if (!ts.isPropertyAssignment(tableProperty) || !ts.isObjectLiteralExpression(tableProperty.initializer)) {
+              continue;
+            }
+            var table = tableProperty.name.getText(source).replace(/^['"]|['"]$/g, "");
+            var tableRelations = (_relations_get = relations.get(table)) !== null && _relations_get !== void 0 ? _relations_get : /* @__PURE__ */new Map();
+            var _iteratorNormalCompletion1 = true,
+              _didIteratorError1 = false,
+              _iteratorError1 = void 0;
+            try {
+              for (var _iterator1 = tableProperty.initializer.properties[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+                var relationProperty = _step1.value;
+                if (!ts.isPropertyAssignment(relationProperty) || !ts.isCallExpression(relationProperty.initializer)) {
+                  continue;
+                }
+                var expression = relationProperty.initializer.expression;
+                if (!ts.isPropertyAccessExpression(expression)) continue;
+                var name = relationProperty.name.getText(source).replace(/^['"]|['"]$/g, "");
+                tableRelations.set(name, expression.name.text);
+              }
+            } catch (err) {
+              _didIteratorError1 = true;
+              _iteratorError1 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                  _iterator1.return();
+                }
+              } finally {
+                if (_didIteratorError1) {
+                  throw _iteratorError1;
+                }
+              }
+            }
+            relations.set(table, tableRelations);
+          }
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+              _iterator2.return();
+            }
+          } finally {
+            if (_didIteratorError2) {
+              throw _iteratorError2;
+            }
+          }
+        }
+      };
+      visit(source);
+    };
+    for (var _iterator = paths.filter(function (path) {
+        return (0, import_path.basename)(path) === "relations.ts";
+      })[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return relations;
+}
+function tableColumns(ts, paths, namespaces) {
+  var columns = /* @__PURE__ */new Map();
+  var sources = /* @__PURE__ */new Set([...paths, ...namespaces.flatMap(function (namespace) {
+    return namespace.sourcePaths;
+  })]);
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    var _loop = function () {
+      var path = _step.value;
+      var source = ts.createSourceFile(path, (0, import_fs.readFileSync)(path, "utf8"), ts.ScriptTarget.Latest, true);
+      var visit = function visit1(node) {
+        if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name) || !node.initializer) {
+          ts.forEachChild(node, visit);
+          return;
+        }
+        var tableNames = /* @__PURE__ */new Set([node.name.text]);
+        var foundColumns = null;
+        var inspect = function inspect1(candidate) {
+          if (!ts.isCallExpression(candidate)) {
+            ts.forEachChild(candidate, inspect);
+            return;
+          }
+          var _iteratorNormalCompletion3 = true,
+            _didIteratorError3 = false,
+            _iteratorError3 = void 0;
+          try {
+            for (var _iterator3 = candidate.arguments[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+              var argument = _step3.value;
+              if (ts.isStringLiteral(argument) && /table/i.test(candidate.expression.getText(source))) {
+                tableNames.add(argument.text);
+              }
+              if (ts.isObjectLiteralExpression(argument)) foundColumns = argument;
+            }
+          } catch (err) {
+            _didIteratorError3 = true;
+            _iteratorError3 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                _iterator3.return();
+              }
+            } finally {
+              if (_didIteratorError3) {
+                throw _iteratorError3;
+              }
+            }
+          }
+          inspect(candidate.expression);
+        };
+        inspect(node.initializer);
+        if (foundColumns) {
+          var names = new Set(foundColumns.properties.map(function (property) {
+            var _property_name;
+            return (_property_name = property.name) === null || _property_name === void 0 ? void 0 : _property_name.getText(source).replace(/^['"]|['"]$/g, "");
+          }).filter(function (name) {
+            return Boolean(name);
+          }));
+          var _iteratorNormalCompletion2 = true,
+            _didIteratorError2 = false,
+            _iteratorError2 = void 0;
+          try {
+            for (var _iterator2 = tableNames[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+              var tableName = _step2.value;
+              columns.set(tableName, names);
+            }
+          } catch (err) {
+            _didIteratorError2 = true;
+            _iteratorError2 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                _iterator2.return();
+              }
+            } finally {
+              if (_didIteratorError2) {
+                throw _iteratorError2;
+              }
+            }
+          }
+        }
+        ts.forEachChild(node, visit);
+      };
+      visit(source);
+    };
+    for (var _iterator = sources[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) _loop();
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return columns;
+}
+function relatedTables(ts, namespace, relations) {
+  if (!namespace.queryPath) return [];
+  var source = ts.createSourceFile(namespace.queryPath, (0, import_fs.readFileSync)(namespace.queryPath, "utf8"), ts.ScriptTarget.Latest, true);
+  var reached = [];
+  var functions = /* @__PURE__ */new Map();
+  var exported = /* @__PURE__ */new Set();
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = source.statements[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var statement = _step.value;
+      if (ts.isVariableStatement(statement)) {
+        var _statement_modifiers;
+        var isExported = (_statement_modifiers = statement.modifiers) === null || _statement_modifiers === void 0 ? void 0 : _statement_modifiers.some(function (modifier) {
+          return modifier.kind === ts.SyntaxKind.ExportKeyword;
+        });
+        var _iteratorNormalCompletion1 = true,
+          _didIteratorError1 = false,
+          _iteratorError1 = void 0;
+        try {
+          for (var _iterator1 = statement.declarationList.declarations[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+            var declaration = _step1.value;
+            if (ts.isIdentifier(declaration.name) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) {
+              functions.set(declaration.name.text, declaration.initializer.body);
+              if (isExported) exported.add(declaration.name.text);
+            }
+          }
+        } catch (err) {
+          _didIteratorError1 = true;
+          _iteratorError1 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+              _iterator1.return();
+            }
+          } finally {
+            if (_didIteratorError1) {
+              throw _iteratorError1;
+            }
+          }
+        }
+      } else if (ts.isFunctionDeclaration(statement) && statement.name && statement.body) {
+        var _statement_modifiers1;
+        functions.set(statement.name.text, statement.body);
+        if ((_statement_modifiers1 = statement.modifiers) === null || _statement_modifiers1 === void 0 ? void 0 : _statement_modifiers1.some(function (modifier) {
+          return modifier.kind === ts.SyntaxKind.ExportKeyword;
+        })) {
+          exported.add(statement.name.text);
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var rootTable = function rootTable2(node) {
+    var _ref;
+    var _text_match;
+    var text = node.getText(source);
+    return (_ref = (_text_match = text.match(/(?:\bzql|\.query)\.([A-Za-z_$][\w$]*)/)) === null || _text_match === void 0 ? void 0 : _text_match[1]) !== null && _ref !== void 0 ? _ref : null;
+  };
+  var visiting = /* @__PURE__ */new Set();
+  var visit = function visit1(node, currentTable, query) {
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "related") {
+      var _rootTable;
+      var _relations_get;
+      var nameArg = node.arguments[0];
+      if (!nameArg || !ts.isStringLiteral(nameArg)) {
+        throw new Error(`[on-zero] ${namespace.name}.${query} uses related() without a string literal; sync membership must be statically derivable`);
+      }
+      var sourceTable = (_rootTable = rootTable(node.expression.expression)) !== null && _rootTable !== void 0 ? _rootTable : currentTable;
+      var target = (_relations_get = relations.get(sourceTable)) === null || _relations_get === void 0 ? void 0 : _relations_get.get(nameArg.text);
+      if (!target) {
+        throw new Error(`[on-zero] ${namespace.name}.${query} related('${nameArg.text}') cannot be resolved from table '${sourceTable}' through relations.ts`);
+      }
+      reached.push({
+        table: target,
+        query
+      });
+      visit(node.expression.expression, currentTable, query);
+      var callback = node.arguments[1];
+      if (callback && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))) {
+        visit(callback.body, target, query);
+      }
+      return;
+    }
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      var helper = functions.get(node.expression.text);
+      var key = `${query}:${node.expression.text}`;
+      if (helper && !visiting.has(key)) {
+        visiting.add(key);
+        visit(helper, currentTable, query);
+        visiting.delete(key);
+      }
+    }
+    ts.forEachChild(node, function (child) {
+      return visit(child, currentTable, query);
+    });
+  };
+  var _iteratorNormalCompletion2 = true,
+    _didIteratorError2 = false,
+    _iteratorError2 = void 0;
+  try {
+    for (var _iterator2 = exported[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+      var name = _step2.value;
+      if (["mutate", "schema", "where"].includes(name)) continue;
+      visit(functions.get(name), namespace.name, name);
+    }
+  } catch (err) {
+    _didIteratorError2 = true;
+    _iteratorError2 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+        _iterator2.return();
+      }
+    } finally {
+      if (_didIteratorError2) {
+        throw _iteratorError2;
+      }
+    }
+  }
+  return reached;
+}
+function mutationSupportTables(ts, baseDir, sourceRoots, namespace) {
+  if (!namespace.modelPath) return [];
+  var tables = /* @__PURE__ */new Set();
+  var visited = /* @__PURE__ */new Set();
+  var scan = function scan1(path) {
+    if (visited.has(path)) return;
+    visited.add(path);
+    var source = ts.createSourceFile(path, (0, import_fs.readFileSync)(path, "utf8"), ts.ScriptTarget.Latest, true);
+    var visit = function visit1(node) {
+      if (ts.isPropertyAccessExpression(node) && ts.isPropertyAccessExpression(node.expression) && ["mutate", "query"].includes(node.expression.name.text)) {
+        var transaction = node.expression.expression;
+        if (ts.isIdentifier(transaction) && transaction.text === "tx" || ts.isPropertyAccessExpression(transaction) && transaction.name.text === "tx") {
+          tables.add(node.name.text);
+        }
+      }
+      if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+        var specifier = node.moduleSpecifier.text;
+        var unresolved = specifier.startsWith("~/data/") ? (0, import_path.resolve)(baseDir, specifier.slice("~/data/".length)) : specifier.startsWith(".") ? (0, import_path.resolve)((0, import_path.dirname)(path), specifier) : null;
+        if (unresolved) {
+          var _loop = function (_i2, _iter2) {
+            var candidate = _iter2[_i2];
+            if ((0, import_fs.existsSync)(candidate) && sourceRoots.some(function (root) {
+              return isWithin(root, candidate);
+            })) {
+              scan(candidate);
+              return "break";
+            }
+          };
+          for (var _i = 0, _iter = [unresolved.endsWith(".ts") ? unresolved : `${unresolved}.ts`, (0, import_path.resolve)(unresolved, "index.ts")]; _i < _iter.length; _i++) {
+            var _ret = _loop(_i, _iter);
+            if (_ret === "break") break;
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(source);
+  };
+  scan(namespace.modelPath);
+  return [...tables].sort();
+}
+function assertNoInstanceFiles(roots) {
+  var visited = /* @__PURE__ */new Set();
+  var walk = function walk1(dir) {
+    if (visited.has(dir) || !(0, import_fs.existsSync)(dir)) return;
+    visited.add(dir);
+    var _iteratorNormalCompletion2 = true,
+      _didIteratorError2 = false,
+      _iteratorError2 = void 0;
+    try {
+      for (var _iterator2 = (0, import_fs.readdirSync)(dir, {
+          withFileTypes: true
+        })[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+        var entry = _step2.value;
+        if (entry.name === "node_modules" || entry.name === "generated") continue;
+        var path = (0, import_path.resolve)(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(path);
+        } else if (entry.isFile() && entry.name === "instance.ts") {
+          throw new Error(`[on-zero] ${path} uses removed instance.ts configuration; delete it and configure instances in on-zero.config.ts`);
+        }
+      }
+    } catch (err) {
+      _didIteratorError2 = true;
+      _iteratorError2 = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+          _iterator2.return();
+        }
+      } finally {
+        if (_didIteratorError2) {
+          throw _iteratorError2;
+        }
+      }
+    }
+  };
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = roots[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var root = _step.value;
+      walk(root);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+}
+function assertNoUnclaimedNamespaces(ts, baseDir, configPath, instanceDirs) {
+  var walk = function walk1(dir) {
+    if (instanceDirs.some(function (instanceDir) {
+      return isWithin(instanceDir, dir);
+    })) return;
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = (0, import_fs.readdirSync)(dir, {
+          withFileTypes: true
+        })[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var entry = _step.value;
+        if (entry.name === "node_modules" || entry.name === "generated") continue;
+        var path = (0, import_path.resolve)(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(path);
+          continue;
+        }
+        if (!entry.isFile() || !isSourceFile(entry.name) || path === configPath || entry.name === "instance.ts") {
+          continue;
+        }
+        if (hasNamespaceExports(ts, baseDir, path)) {
+          throw new Error(`[on-zero] data namespace ${path} is outside every instance directory declared in ${configPath}`);
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  };
+  walk(baseDir);
+}
+function discoverDataLayout(ts, baseDir, configPath) {
+  var _ref;
+  var config = readDataConfig(ts, baseDir, configPath);
+  var configured = (_ref = config === null || config === void 0 ? void 0 : config.instances) !== null && _ref !== void 0 ? _ref : [{
+    name: "default",
+    dir: baseDir,
+    scope: null,
+    supportTables: []
+  }];
+  var sourceRoots = [... /* @__PURE__ */new Set([baseDir, ...configured.map(function (instance2) {
+    return instance2.dir;
+  })])];
+  assertNoInstanceFiles(sourceRoots);
+  if (config) {
+    assertNoUnclaimedNamespaces(ts, baseDir, config.path, configured.map(function (instance2) {
+      return instance2.dir;
+    }));
+  }
+  var instances = configured.map(function (instance2) {
+    return {
+      name: instance2.name,
+      dir: instance2.dir,
+      scope: instance2.scope,
+      namespaces: [],
+      syncTables: [],
+      supportTables: [],
+      declaredSupportTables: instance2.supportTables
+    };
+  });
+  var instanceDirs = new Set(instances.map(function (instance2) {
+    return instance2.dir;
+  }));
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = instances[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var instance = _step.value;
+      instance.namespaces = discoverNamespaces(ts, baseDir, instance, instanceDirs);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var namespaces = instances.flatMap(function (instance2) {
+    return instance2.namespaces;
+  });
+  var owners = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion1 = true,
+    _didIteratorError1 = false,
+    _iteratorError1 = void 0;
+  try {
+    for (var _iterator1 = namespaces[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+      var namespace = _step1.value;
+      var owner = owners.get(namespace.name);
+      if (owner) {
+        throw new Error(`[on-zero] namespace '${namespace.name}' is claimed by instances '${owner}' and '${namespace.instance}'`);
+      }
+      owners.set(namespace.name, namespace.instance);
+    }
+  } catch (err) {
+    _didIteratorError1 = true;
+    _iteratorError1 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+        _iterator1.return();
+      }
+    } finally {
+      if (_didIteratorError1) {
+        throw _iteratorError1;
+      }
+    }
+  }
+  var metadata = metadataPaths(baseDir);
+  var relations = relationTargets(ts, metadata);
+  var columns = tableColumns(ts, metadata, namespaces);
+  var relatedOwners = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion2 = true,
+    _didIteratorError2 = false,
+    _iteratorError2 = void 0;
+  try {
+    for (var _iterator2 = instances[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+      var instance1 = _step2.value;
+      var syncTables = new Set(instance1.namespaces.map(function (namespace2) {
+        return namespace2.name;
+      }));
+      var _iteratorNormalCompletion3 = true,
+        _didIteratorError3 = false,
+        _iteratorError3 = void 0;
+      try {
+        for (var _iterator3 = instance1.namespaces[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+          var namespace1 = _step3.value;
+          var _iteratorNormalCompletion4 = true,
+            _didIteratorError4 = false,
+            _iteratorError4 = void 0;
+          try {
+            for (var _iterator4 = relatedTables(ts, namespace1, relations)[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+              var reached = _step4.value;
+              var _owners_get;
+              var owner1 = (_owners_get = owners.get(reached.table)) !== null && _owners_get !== void 0 ? _owners_get : relatedOwners.get(reached.table);
+              if (owner1 && owner1 !== instance1.name) {
+                throw new Error(`[on-zero] ${namespace1.name}.${reached.query} in instance '${instance1.name}' reaches table '${reached.table}' owned by instance '${owner1}'`);
+              }
+              relatedOwners.set(reached.table, instance1.name);
+              syncTables.add(reached.table);
+            }
+          } catch (err) {
+            _didIteratorError4 = true;
+            _iteratorError4 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+                _iterator4.return();
+              }
+            } finally {
+              if (_didIteratorError4) {
+                throw _iteratorError4;
+              }
+            }
+          }
+        }
+      } catch (err) {
+        _didIteratorError3 = true;
+        _iteratorError3 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+            _iterator3.return();
+          }
+        } finally {
+          if (_didIteratorError3) {
+            throw _iteratorError3;
+          }
+        }
+      }
+      instance1.syncTables = [...syncTables].sort();
+      if (instance1.scope) {
+        var _iteratorNormalCompletion5 = true,
+          _didIteratorError5 = false,
+          _iteratorError5 = void 0;
+        try {
+          for (var _iterator5 = instance1.syncTables[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+            var table = _step5.value;
+            var _columns_get;
+            if (!((_columns_get = columns.get(table)) === null || _columns_get === void 0 ? void 0 : _columns_get.has(instance1.scope))) {
+              throw new Error(`[on-zero] table '${table}' in instance '${instance1.name}' is missing scope column '${instance1.scope}'`);
+            }
+          }
+        } catch (err) {
+          _didIteratorError5 = true;
+          _iteratorError5 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+              _iterator5.return();
+            }
+          } finally {
+            if (_didIteratorError5) {
+              throw _iteratorError5;
+            }
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError2 = true;
+    _iteratorError2 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+        _iterator2.return();
+      }
+    } finally {
+      if (_didIteratorError2) {
+        throw _iteratorError2;
+      }
+    }
+  }
+  var _iteratorNormalCompletion6 = true,
+    _didIteratorError6 = false,
+    _iteratorError6 = void 0;
+  try {
+    var _loop = function () {
+      var instance2 = _step6.value;
+      var supportTables = new Set(instance2.declaredSupportTables);
+      var _iteratorNormalCompletion7 = true,
+        _didIteratorError7 = false,
+        _iteratorError7 = void 0;
+      try {
+        for (var _iterator7 = instance2.namespaces[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+          var namespace2 = _step7.value;
+          var _iteratorNormalCompletion12 = true,
+            _didIteratorError12 = false,
+            _iteratorError12 = void 0;
+          try {
+            for (var _iterator12 = mutationSupportTables(ts, baseDir, sourceRoots, namespace2)[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
+              var table2 = _step12.value;
+              if (owners.has(table2) || relatedOwners.has(table2)) continue;
+              if (!instance2.syncTables.includes(table2)) {
+                supportTables.add(table2);
+              }
+            }
+          } catch (err) {
+            _didIteratorError12 = true;
+            _iteratorError12 = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+                _iterator12.return();
+              }
+            } finally {
+              if (_didIteratorError12) {
+                throw _iteratorError12;
+              }
+            }
+          }
+        }
+      } catch (err) {
+        _didIteratorError7 = true;
+        _iteratorError7 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
+            _iterator7.return();
+          }
+        } finally {
+          if (_didIteratorError7) {
+            throw _iteratorError7;
+          }
+        }
+      }
+      instance2.supportTables = [...supportTables].filter(function (table3) {
+        return !instance2.syncTables.includes(table3);
+      }).sort();
+    };
+    for (var _iterator6 = instances[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) _loop();
+  } catch (err) {
+    _didIteratorError6 = true;
+    _iteratorError6 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+        _iterator6.return();
+      }
+    } finally {
+      if (_didIteratorError6) {
+        throw _iteratorError6;
+      }
+    }
+  }
+  return {
+    instances,
+    namespaces,
+    metadataPaths: config ? [...metadata, config.path].sort() : metadata,
+    sourceRoots
+  };
+}
+function namespaceImportPath(baseDir, path) {
+  return `../${toImportPath(baseDir, path)}`;
+}
+//# sourceMappingURL=generate-layout.native.js.map