@tenonhq/dovetail-core 0.0.85

package/dist/config.js

@@ -0,0 +1,697 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfigs = void 0;
+exports.getConfig = getConfig;
+exports.getConfigPath = getConfigPath;
+exports.checkConfigPath = checkConfigPath;
+exports.getRootDir = getRootDir;
+exports.getManifest = getManifest;
+exports.getManifestPath = getManifestPath;
+exports.getScopeManifestPath = getScopeManifestPath;
+exports.getSourcePath = getSourcePath;
+exports.getSourcePathForScope = getSourcePathForScope;
+exports.getBuildPath = getBuildPath;
+exports.getEnvPath = getEnvPath;
+exports.getDiffPath = getDiffPath;
+exports.getDiffFile = getDiffFile;
+exports.getRefresh = getRefresh;
+exports.getDefaultConfigFile = getDefaultConfigFile;
+exports.generateConfigFile = generateConfigFile;
+exports.loadScopeManifest = loadScopeManifest;
+exports.updateManifest = updateManifest;
+exports.isMultiScopeManifest = isMultiScopeManifest;
+exports.resolveManifestForScope = resolveManifestForScope;
+exports.resolveScopeFromPath = resolveScopeFromPath;
+exports.loadConfigPath = loadConfigPath;
+exports.isDirectiveKey = isDirectiveKey;
+exports.stripDirectiveKeys = stripDirectiveKeys;
+exports.resolveConfigForScope = resolveConfigForScope;
+exports.getReadOnlyTablesForScope = getReadOnlyTablesForScope;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importStar(require("fs"));
+const Logger_1 = require("./Logger");
+const defaultOptions_1 = require("./defaultOptions");
+// Resolve an artifact path, preferring the dove.* name and falling back to the
+// legacy sinc.* name when only the legacy file exists. Returns the new path if
+// neither exists (so writes default to the new name).
+function resolveDovePath(rootDir, doveName, sincName) {
+    const newPath = path_1.default.join(rootDir, doveName);
+    const oldPath = path_1.default.join(rootDir, sincName);
+    if (fs_1.default.existsSync(newPath))
+        return newPath;
+    if (fs_1.default.existsSync(oldPath))
+        return oldPath;
+    return newPath;
+}
+const DEFAULT_CONFIG = {
+    sourceDirectory: "src",
+    buildDirectory: "build",
+    rules: [],
+    includes: defaultOptions_1.includes,
+    excludes: defaultOptions_1.excludes,
+    tableOptions: {},
+    refreshInterval: 30,
+    scopes: {},
+};
+let root_dir;
+let config;
+let manifest;
+let config_path;
+let source_path;
+let build_path;
+let env_path;
+let manifest_path;
+let diff_path;
+let diff_file;
+let refresh_interval;
+const loadConfigs = async () => {
+    try {
+        let noConfigPath = false; //Prevents logging error messages during init
+        const path = await loadConfigPath();
+        if (path)
+            config_path = path;
+        else
+            noConfigPath = true;
+        await loadRootDir(noConfigPath);
+        const cfg = await loadConfig(noConfigPath);
+        if (cfg)
+            config = cfg;
+        await loadEnvPath();
+        await loadSourcePath();
+        await loadBuildPath();
+        await loadManifestPath();
+        await loadManifest();
+        await loadDiffPath();
+        await loadDiffFile();
+        await loadRefresh();
+    }
+    catch (e) {
+        throw e;
+    }
+};
+exports.loadConfigs = loadConfigs;
+function getConfig() {
+    if (config)
+        return config;
+    throw new Error("Error getting config");
+}
+function getConfigPath() {
+    if (config_path)
+        return config_path;
+    throw new Error("Error getting config path");
+}
+function checkConfigPath() {
+    if (config_path)
+        return config_path;
+    return false;
+}
+function getRootDir() {
+    if (root_dir)
+        return root_dir;
+    throw new Error("Error getting root directory");
+}
+function getManifest(setup = false) {
+    if (manifest)
+        return manifest;
+    if (!setup)
+        throw new Error("Error getting manifest");
+}
+function getManifestPath(scope) {
+    if (scope) {
+        const rootDir = getRootDir();
+        return resolveDovePath(rootDir, `dove.manifest.${scope}.json`, `sinc.manifest.${scope}.json`);
+    }
+    if (manifest_path)
+        return manifest_path;
+    throw new Error("Error getting manifest path");
+}
+function getScopeManifestPath(scope) {
+    const rootDir = getRootDir();
+    return resolveDovePath(rootDir, `dove.manifest.${scope}.json`, `sinc.manifest.${scope}.json`);
+}
+function getSourcePath() {
+    if (source_path)
+        return source_path;
+    throw new Error("Error getting source path");
+}
+function getSourcePathForScope(scopeName) {
+    var cfg = getConfig();
+    var scopeConfig = cfg.scopes && cfg.scopes[scopeName];
+    if (scopeConfig && typeof scopeConfig === "object" && scopeConfig.sourceDirectory) {
+        return path_1.default.resolve(getRootDir(), scopeConfig.sourceDirectory);
+    }
+    return getSourcePath();
+}
+function getBuildPath() {
+    if (build_path)
+        return build_path;
+    throw new Error("Error getting build path");
+}
+function getEnvPath() {
+    if (env_path)
+        return env_path;
+    throw new Error("Error getting env path");
+}
+function getDiffPath() {
+    if (diff_path)
+        return diff_path;
+    throw new Error("Error getting diff path");
+}
+function getDiffFile() {
+    if (diff_file)
+        return diff_file;
+    throw new Error("Error getting diff file");
+}
+function getRefresh() {
+    if (refresh_interval)
+        return refresh_interval;
+    throw new Error("Error getting refresh interval");
+}
+function getDefaultConfigFile() {
+    return `
+    module.exports = {
+      sourceDirectory: "src",
+      buildDirectory: "build",
+      rules: [],
+      excludes:{},
+      includes:{},
+      tableOptions:{},
+      refreshInterval:30
+    };
+    `.trim();
+}
+/**
+ * @description Generates a full dove.config.js with multi-scope support, table whitelist,
+ * field type overrides, and plugin rules. Used by `dove init` when creating a new config.
+ * @param {Object} params - Configuration parameters
+ * @param {Array<{scope: string, sourceDirectory: string}>} params.scopes - Selected scopes with source directories
+ * @returns {string} Complete dove.config.js file content
+ */
+function generateConfigFile(params) {
+    var scopeEntries = params.scopes.map(function (s) {
+        return "\t\t" + s.scope + ": {\n\t\t\tsourceDirectory: \"" + s.sourceDirectory + "\",\n\t\t},";
+    }).join("\n");
+    return "module.exports = {\n" +
+        "\tsourceDirectory: \"src\",\n" +
+        "\tbuildDirectory: \"build\",\n" +
+        "\n" +
+        "\t// Plugin Rules Configuration\n" +
+        "\trules: [\n" +
+        "\t\t{\n" +
+        "\t\t\tmatch: /sys_script_include.*\\.ts$/,\n" +
+        "\t\t\tplugins: [\n" +
+        "\t\t\t\t{\n" +
+        "\t\t\t\t\tname: \"@tenonhq/dovetail-typescript-plugin\",\n" +
+        "\t\t\t\t\toptions: {\n" +
+        "\t\t\t\t\t\ttranspile: true,\n" +
+        "\t\t\t\t\t\ttypeCheck: true,\n" +
+        "\t\t\t\t\t\ttsconfig: \"./tsconfig.servicenow.json\",\n" +
+        "\t\t\t\t\t},\n" +
+        "\t\t\t\t},\n" +
+        "\t\t\t\t{\n" +
+        "\t\t\t\t\tname: \"@tenonhq/dovetail-eslint-plugin\",\n" +
+        "\t\t\t\t\toptions: {\n" +
+        "\t\t\t\t\t\tconfigFile: \"./.eslintrc.js\",\n" +
+        "\t\t\t\t\t\tfix: false,\n" +
+        "\t\t\t\t\t\tcache: true,\n" +
+        "\t\t\t\t\t},\n" +
+        "\t\t\t\t},\n" +
+        "\t\t\t\t{\n" +
+        "\t\t\t\t\tname: \"@tenonhq/dovetail-babel-plugin\",\n" +
+        "\t\t\t\t\toptions: {\n" +
+        "\t\t\t\t\t\tconfigFile: \"./.babelrc\",\n" +
+        "\t\t\t\t\t},\n" +
+        "\t\t\t\t},\n" +
+        "\t\t\t\t{\n" +
+        "\t\t\t\t\tname: \"@tenonhq/dovetail-prettier-plugin\",\n" +
+        "\t\t\t\t\toptions: {\n" +
+        "\t\t\t\t\t\tconfigFile: \"./.prettierrc.js\",\n" +
+        "\t\t\t\t\t},\n" +
+        "\t\t\t\t},\n" +
+        "\t\t\t],\n" +
+        "\t\t},\n" +
+        "\t],\n" +
+        "\n" +
+        "\tincludes: {\n" +
+        "\t\t_tables: [\n" +
+        "\t\t\t\"sys_script_include\",\n" +
+        "\t\t\t\"sys_script\",\n" +
+        "\t\t\t\"sys_ui_script\",\n" +
+        "\t\t\t\"sys_ui_page\",\n" +
+        "\t\t\t\"sys_ux_client_script\",\n" +
+        "\t\t\t\"sys_processor\",\n" +
+        "\t\t\t\"sys_ws_operation\",\n" +
+        "\t\t\t\"sys_rest_message_fn\",\n" +
+        "\t\t\t\"sys_ui_action\",\n" +
+        "\t\t\t\"sys_security_acl\",\n" +
+        "\t\t\t\"sysevent_script_action\",\n" +
+        "\t\t\t\"sys_ux_macroponent\",\n" +
+        "\t\t\t\"sys_ux_event\",\n" +
+        "\t\t\t\"sys_ux_client_script_include\",\n" +
+        "\t\t\t\"sys_ux_screen\",\n" +
+        "\t\t\t\"sys_script_fix\",\n" +
+        "\t\t],\n" +
+        "\t\tsys_script_include: {\n" +
+        "\t\t\tscript: { type: \"js\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_script: {\n" +
+        "\t\t\tscript: { type: \"js\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_ui_script: {\n" +
+        "\t\t\tscript: { type: \"js\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_ui_page: {\n" +
+        "\t\t\tprocessing_script: { type: \"js\" },\n" +
+        "\t\t\tclient_script: { type: \"js\" },\n" +
+        "\t\t\thtml: { type: \"html\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_processor: {\n" +
+        "\t\t\tscript: { type: \"js\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_ws_operation: {\n" +
+        "\t\t\toperation_script: { type: \"js\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_rest_message_fn: {\n" +
+        "\t\t\tcontent: { type: \"txt\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_ui_action: {\n" +
+        "\t\t\tscript: { type: \"js\" },\n" +
+        "\t\t\tclient_script_v2: { type: \"js\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_security_acl: {\n" +
+        "\t\t\tscript: { type: \"js\" },\n" +
+        "\t\t},\n" +
+        "\t\tsysevent_script_action: {\n" +
+        "\t\t\tscript: { type: \"js\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_script_fix: {\n" +
+        "\t\t\tscript: { type: \"js\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_ux_macroponent: {\n" +
+        "\t\t\tcomposition: { type: \"json\" },\n" +
+        "\t\t\tprops: { type: \"json\" },\n" +
+        "\t\t\tdata: { type: \"json\" },\n" +
+        "\t\t\trequired_translations: { type: \"json\" },\n" +
+        "\t\t\troot_component_definition: { type: \"json\" },\n" +
+        "\t\t\tstate_properties: { type: \"json\" },\n" +
+        "\t\t\troot_component_config: { type: \"json\" },\n" +
+        "\t\t\tinternal_event_mappings: { type: \"json\" },\n" +
+        "\t\t\tstate_persistence_config: { type: \"json\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_ux_event: {\n" +
+        "\t\t\tdescription: { type: \"txt\" },\n" +
+        "\t\t\tevent_name: { type: \"txt\" },\n" +
+        "\t\t\tlabel: { type: \"txt\" },\n" +
+        "\t\t\tprops: { type: \"json\" },\n" +
+        "\t\t\trequired_translations: { type: \"json\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_ux_client_script: {\n" +
+        "\t\t\tscript: { type: \"js\" },\n" +
+        "\t\t\tname: { type: \"txt\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_ux_client_script_include: {\n" +
+        "\t\t\tscript: { type: \"js\" },\n" +
+        "\t\t\tname: { type: \"txt\" },\n" +
+        "\t\t},\n" +
+        "\t\tsys_ux_screen: {\n" +
+        "\t\t\tmacroponent_config: { type: \"json\" },\n" +
+        "\t\t\tevent_mappings: { type: \"json\" },\n" +
+        "\t\t},\n" +
+        "\t\t_scopes: {},\n" +
+        "\t},\n" +
+        "\n" +
+        "\texcludes: {\n" +
+        "\t\t_tables: [],\n" +
+        "\t},\n" +
+        "\n" +
+        "\tmanifestOptions: {\n" +
+        "\t\tupdateFields: true,\n" +
+        "\t\tupdateDependencies: true,\n" +
+        "\t},\n" +
+        "\n" +
+        "\tserver: {\n" +
+        "\t\twatchPath: \"./src\",\n" +
+        "\t},\n" +
+        "\n" +
+        "\tscopes: {\n" +
+        scopeEntries + "\n" +
+        "\t},\n" +
+        "};\n";
+}
+async function loadConfig(skipConfigPath = false) {
+    if (skipConfigPath) {
+        Logger_1.logger.warn("Couldn't find config file. Loading default...");
+        return DEFAULT_CONFIG;
+    }
+    try {
+        let configPath = getConfigPath();
+        if (configPath) {
+            let projectConfig = (await Promise.resolve(`${configPath}`).then(s => __importStar(require(s)))).default;
+            // Config is king — no merging with defaults. dove.config.js is the single source of truth.
+            var { includes: pIncludes = {}, excludes: pExcludes = {}, tableOptions: pTableOptions = {}, scopes: pScopes = {}, } = projectConfig;
+            projectConfig.includes = pIncludes;
+            projectConfig.excludes = pExcludes;
+            projectConfig.tableOptions = pTableOptions;
+            projectConfig.scopes = pScopes;
+            return projectConfig;
+        }
+        else {
+            Logger_1.logger.warn("Couldn't find config file. Loading default...");
+            return DEFAULT_CONFIG;
+        }
+    }
+    catch (e) {
+        let message;
+        if (e instanceof Error)
+            message = e.message;
+        else
+            message = String(e);
+        Logger_1.logger.warn(message);
+        Logger_1.logger.warn("Couldn't find config file. Loading default...");
+        return DEFAULT_CONFIG;
+    }
+}
+async function loadManifest() {
+    try {
+        // Try to load legacy single manifest first
+        let manifestString = await fs_1.promises.readFile(getManifestPath(), "utf-8");
+        manifest = JSON.parse(manifestString);
+    }
+    catch (e) {
+        // If no single manifest, try to load all scope-specific manifests
+        manifest = await loadAllScopeManifests();
+    }
+}
+async function loadAllScopeManifests() {
+    try {
+        const rootDir = getRootDir();
+        const files = await fs_1.promises.readdir(rootDir);
+        const manifestFiles = files.filter(f => ((f.startsWith('dove.manifest.') && f !== 'dove.manifest.json') ||
+            (f.startsWith('sinc.manifest.') && f !== 'sinc.manifest.json')) &&
+            f.endsWith('.json'));
+        if (manifestFiles.length === 0) {
+            return undefined;
+        }
+        // Combine all scope manifests into a single structure for backward compatibility
+        const combinedManifest = {};
+        for (const file of manifestFiles) {
+            const scope = file.replace(/^(dove|sinc)\.manifest\./, '').replace('.json', '');
+            const manifestPath = path_1.default.join(rootDir, file);
+            try {
+                const content = await fs_1.promises.readFile(manifestPath, "utf-8");
+                const scopeManifest = JSON.parse(content);
+                // If the manifest already has the scope at root level, use it directly
+                if (scopeManifest.scope && scopeManifest.tables) {
+                    combinedManifest[scope] = scopeManifest;
+                }
+                else {
+                    // Otherwise wrap it
+                    combinedManifest[scope] = scopeManifest;
+                }
+            }
+            catch (e) {
+                Logger_1.logger.warn(`Failed to load manifest for scope ${scope}: ${e}`);
+            }
+        }
+        return Object.keys(combinedManifest).length > 0 ? combinedManifest : undefined;
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+async function loadScopeManifest(scope) {
+    try {
+        const manifestPath = getScopeManifestPath(scope);
+        const content = await fs_1.promises.readFile(manifestPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+function updateManifest(man) {
+    manifest = man;
+}
+function isMultiScopeManifest(man) {
+    return typeof man === "object" && man !== null && !man.scope && !man.tables;
+}
+function resolveManifestForScope(man, scope) {
+    if (!isMultiScopeManifest(man)) {
+        if (!scope || man.scope === scope) {
+            return man;
+        }
+        return undefined;
+    }
+    var scopeMan = man[scope];
+    if (scopeMan && scopeMan.tables) {
+        return scopeMan;
+    }
+    return undefined;
+}
+function resolveScopeFromPath(filePath) {
+    var cfg = getConfig();
+    if (!cfg.scopes)
+        return undefined;
+    var scopeNames = Object.keys(cfg.scopes);
+    for (var i = 0; i < scopeNames.length; i++) {
+        var scopeSourcePath = getSourcePathForScope(scopeNames[i]);
+        if (filePath.indexOf(scopeSourcePath) === 0) {
+            return scopeNames[i];
+        }
+    }
+    return undefined;
+}
+// Exported for tests only.
+async function loadConfigPath(pth) {
+    if (!pth) {
+        pth = process.cwd();
+    }
+    // check to see if config is found
+    let files = await fs_1.promises.readdir(pth);
+    if (files.includes("dove.config.js")) {
+        return path_1.default.join(pth, "dove.config.js");
+    }
+    if (files.includes("sinc.config.js")) {
+        Logger_1.logger.warn("Found legacy 'sinc.config.js' — please rename to 'dove.config.js' (run 'npx dove migrate'). Continuing with the legacy file.");
+        return path_1.default.join(pth, "sinc.config.js");
+    }
+    if (isRoot(pth)) {
+        return false;
+    }
+    return loadConfigPath(path_1.default.dirname(pth));
+    function isRoot(pth) {
+        return path_1.default.parse(pth).root === pth;
+    }
+}
+async function loadRefresh() {
+    let { refreshInterval = 30 } = getConfig();
+    refresh_interval = refreshInterval;
+}
+async function loadSourcePath() {
+    let rootDir = getRootDir();
+    let { sourceDirectory = "src" } = getConfig();
+    source_path = path_1.default.join(rootDir, sourceDirectory);
+}
+async function loadBuildPath() {
+    let rootDir = getRootDir();
+    let { buildDirectory = "build" } = getConfig();
+    build_path = path_1.default.join(rootDir, buildDirectory);
+}
+async function loadEnvPath() {
+    let rootDir = getRootDir();
+    env_path = path_1.default.join(rootDir, ".env");
+}
+async function loadManifestPath() {
+    let rootDir = getRootDir();
+    manifest_path = resolveDovePath(rootDir, "dove.manifest.json", "sinc.manifest.json");
+}
+async function loadDiffPath() {
+    let rootDir = getRootDir();
+    diff_path = resolveDovePath(rootDir, "dove.diff.manifest.json", "sinc.diff.manifest.json");
+}
+async function loadDiffFile() {
+    try {
+        let diffString = await fs_1.promises.readFile(getDiffPath(), "utf-8");
+        diff_file = JSON.parse(diffString);
+    }
+    catch (e) {
+        diff_file = undefined;
+    }
+}
+async function loadRootDir(skip) {
+    if (skip) {
+        root_dir = process.cwd();
+        return;
+    }
+    let configPath = getConfigPath();
+    if (configPath)
+        root_dir = path_1.default.dirname(configPath);
+    else
+        root_dir = process.cwd();
+}
+function isDirectiveKey(key) {
+    return key.charAt(0) === "_";
+}
+function stripDirectiveKeys(obj) {
+    var result = {};
+    var keys = Object.keys(obj || {});
+    for (var i = 0; i < keys.length; i++) {
+        if (!isDirectiveKey(keys[i])) {
+            result[keys[i]] = obj[keys[i]];
+        }
+    }
+    return result;
+}
+function resolveConfigForScope(scopeName, cfgOverride) {
+    var cfg = cfgOverride || getConfig();
+    var cfgIncludes = cfg.includes || {};
+    var cfgExcludes = cfg.excludes || {};
+    // Backward compat: support old "table" key (no underscore)
+    var globalTables = cfgIncludes._tables || [];
+    if (!cfgIncludes._tables && Array.isArray(cfgIncludes.table)) {
+        Logger_1.logger.warn("Deprecation: 'table' key in includes is deprecated. Use '_tables' instead.");
+        globalTables = cfgIncludes.table;
+    }
+    // Resolve scope-specific overrides
+    var scopesDirective = cfgIncludes._scopes || {};
+    var scopeOverride = scopesDirective[scopeName] || {};
+    var scopeTables = scopeOverride._tables || [];
+    // Deduplicated union of global + scope tables
+    var tableSet = {};
+    var i;
+    for (i = 0; i < globalTables.length; i++) {
+        tableSet[globalTables[i]] = true;
+    }
+    for (i = 0; i < scopeTables.length; i++) {
+        tableSet[scopeTables[i]] = true;
+    }
+    // Field overrides: global non-_ keys and scope-specific non-_ keys
+    var globalFieldOverrides = stripDirectiveKeys(cfgIncludes);
+    var scopeFieldOverrides = stripDirectiveKeys(scopeOverride);
+    // Implicitly add tables that have field overrides to the whitelist
+    var globalOverrideTables = Object.keys(globalFieldOverrides);
+    for (i = 0; i < globalOverrideTables.length; i++) {
+        if (!tableSet[globalOverrideTables[i]]) {
+            tableSet[globalOverrideTables[i]] = true;
+        }
+    }
+    var scopeOverrideTables = Object.keys(scopeFieldOverrides);
+    for (i = 0; i < scopeOverrideTables.length; i++) {
+        if (!tableSet[scopeOverrideTables[i]]) {
+            tableSet[scopeOverrideTables[i]] = true;
+        }
+    }
+    var resolvedTables = Object.keys(tableSet);
+    // Resolve excludes _tables
+    var excludeTables = cfgExcludes._tables || [];
+    if (!cfgExcludes._tables && Array.isArray(cfgExcludes.table)) {
+        excludeTables = cfgExcludes.table;
+    }
+    // Remove excluded tables from the resolved list
+    if (excludeTables.length > 0) {
+        var excludeSet = {};
+        for (i = 0; i < excludeTables.length; i++) {
+            excludeSet[excludeTables[i]] = true;
+        }
+        resolvedTables = resolvedTables.filter(function (t) {
+            return !excludeSet[t];
+        });
+    }
+    // Deep merge field overrides: global + scope, scope wins on conflicts per field
+    var fieldOverrides = {};
+    var allTableKeys = {};
+    var gKeys = Object.keys(globalFieldOverrides);
+    var sKeys = Object.keys(scopeFieldOverrides);
+    for (i = 0; i < gKeys.length; i++) {
+        allTableKeys[gKeys[i]] = true;
+    }
+    for (i = 0; i < sKeys.length; i++) {
+        allTableKeys[sKeys[i]] = true;
+    }
+    for (var tblKey in allTableKeys) {
+        var globalEntry = globalFieldOverrides[tblKey];
+        var scopeEntry = scopeFieldOverrides[tblKey];
+        if (globalEntry && scopeEntry && typeof globalEntry === "object" && typeof scopeEntry === "object") {
+            fieldOverrides[tblKey] = Object.assign({}, globalEntry, scopeEntry);
+        }
+        else {
+            fieldOverrides[tblKey] = scopeEntry || globalEntry;
+        }
+    }
+    // API includes: merged field overrides (no _ keys)
+    var apiIncludes = Object.assign({}, fieldOverrides);
+    // API excludes: strip _ keys
+    var apiExcludes = stripDirectiveKeys(cfgExcludes);
+    // Read-only tables: union of global _readOnlyTables and scope-level override.
+    // A table flagged read-only is still pulled from the instance but pushes are
+    // skipped. Default when absent: empty (bidirectional for all tables).
+    var globalReadOnly = Array.isArray(cfgIncludes._readOnlyTables)
+        ? cfgIncludes._readOnlyTables
+        : [];
+    var scopeReadOnly = Array.isArray(scopeOverride._readOnlyTables)
+        ? scopeOverride._readOnlyTables
+        : [];
+    var readOnlySet = {};
+    for (i = 0; i < globalReadOnly.length; i++) {
+        readOnlySet[globalReadOnly[i]] = true;
+    }
+    for (i = 0; i < scopeReadOnly.length; i++) {
+        readOnlySet[scopeReadOnly[i]] = true;
+    }
+    var resolvedReadOnly = Object.keys(readOnlySet);
+    return {
+        tables: resolvedTables,
+        fieldOverrides: fieldOverrides,
+        apiIncludes: apiIncludes,
+        apiExcludes: apiExcludes,
+        readOnlyTables: resolvedReadOnly,
+    };
+}
+// Convenience wrapper for push-side lookups — returns a Set for O(1) membership.
+// Fails safe (empty set = all tables writable) when config isn't available
+// rather than blocking a push over a lookup error.
+function getReadOnlyTablesForScope(scopeName) {
+    try {
+        var resolved = resolveConfigForScope(scopeName);
+        return new Set(resolved.readOnlyTables || []);
+    }
+    catch (e) {
+        return new Set();
+    }
+}