@antelopejs/dms-frontend 0.0.1

package/dist/commands/verify-source.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLocalPackages = parseLocalPackages;
+exports.cmdVerifySource = cmdVerifySource;
+const node_path_1 = require("node:path");
+const commander_1 = require("commander");
+const common_1 = require("../common");
+function collectOption(value, values) {
+    return [...values, value];
+}
+function parseLocalPackages(values) {
+    return Object.fromEntries(values.map((value) => {
+        const separator = value.indexOf("=");
+        if (separator <= 0 || separator === value.length - 1)
+            throw new Error(`Invalid local package "${value}"; expected name=path`);
+        return [value.slice(0, separator), (0, node_path_1.resolve)(value.slice(separator + 1))];
+    }));
+}
+async function verifySource(options) {
+    const runner = (0, node_path_1.join)((0, common_1.getPackageRoot)(), "dist", "verify-source-runner.js");
+    const code = await (0, common_1.runCommand)(process.execPath, [runner], {
+        env: {
+            ...process.env,
+            DMS_LAYER_SOURCE: (0, node_path_1.resolve)(options.layer),
+            DMS_MODULE_SOURCES: JSON.stringify(options.module.map((path) => (0, node_path_1.resolve)(path))),
+            DMS_LOCAL_PACKAGES: JSON.stringify(parseLocalPackages(options.localPackage)),
+        },
+    });
+    if (code !== 0)
+        throw new Error("Source verification failed");
+}
+function cmdVerifySource() {
+    return new commander_1.Command("verify-source")
+        .description("Build and typecheck unpublished DMS frontend sources")
+        .requiredOption("-l, --layer <path>", "DMS frontend package root")
+        .option("-m, --module <path>", "Additional frontend package root (repeatable)", collectOption, [])
+        .option("--local-package <name=path>", "Bind a local package into the generated workspace (repeatable)", collectOption, [])
+        .action(verifySource);
+}

package/dist/common.js

@@ -0,0 +1,24 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config"), exports);
+__exportStar(require("./layers"), exports);
+__exportStar(require("./manifest"), exports);
+__exportStar(require("./fs-sync"), exports);
+__exportStar(require("./layer-watch"), exports);
+__exportStar(require("./materialize"), exports);
+__exportStar(require("./workspace"), exports);
+__exportStar(require("./workspace-setup"), exports);

package/dist/config.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Options = exports.TAILWIND_SOURCE_GLOB = exports.PNPM_LIFECYCLE_SCRIPTS = exports.layerCopyIgnore = exports.LAYER_COPY_BLOCKLIST = exports.FRONTEND_MODULE_ENTRY = exports.LAYERS_SUBDIR = exports.TEMPLATE_FILES = exports.WORKSPACE_DIR_MODE = exports.DEPS_HASH_FILE = exports.DMS_FRONTEND_HOME = void 0;
+exports.writeSecretBearingFile = writeSecretBearingFile;
+exports.normalizeBootstrapSecret = normalizeBootstrapSecret;
+exports.resolveBootstrapSecret = resolveBootstrapSecret;
+exports.sha256Hex = sha256Hex;
+exports.canonicalizeBackendUrl = canonicalizeBackendUrl;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const commander_1 = require("commander");
+const ignore_1 = __importDefault(require("ignore"));
+const discovery_1 = require("./discovery");
+const ANTELOPEJS_HOME = (0, node_path_1.join)((0, node_os_1.homedir)(), ".antelopejs");
+exports.DMS_FRONTEND_HOME = (0, node_path_1.join)(ANTELOPEJS_HOME, "dms-frontend");
+exports.DEPS_HASH_FILE = ".deps-hash";
+const SECRET_BEARING_FILE_MODE = 0o600;
+const TEMP_FILE_SUFFIX = ".tmp";
+exports.WORKSPACE_DIR_MODE = 0o700;
+function writeSecretBearingFile(file, content) {
+    const temp = `${file}.${process.pid}${TEMP_FILE_SUFFIX}`;
+    (0, node_fs_1.writeFileSync)(temp, content, { mode: SECRET_BEARING_FILE_MODE });
+    (0, node_fs_1.chmodSync)(temp, SECRET_BEARING_FILE_MODE);
+    (0, node_fs_1.renameSync)(temp, file);
+}
+exports.TEMPLATE_FILES = [
+    ["vite.config.ts", "vite.config.ts"],
+    ["vite.email.config.ts", "vite.email.config.ts"],
+    ["index.html", "index.html"],
+    ["main.ts", "main.ts"],
+    ["app-runtime.ts", "app-runtime.ts"],
+    ["ssr-renderer.ts", "ssr-renderer.ts"],
+    ["frontend-module.ts", "frontend-module.ts"],
+    ["globals.d.ts", "globals.d.ts"],
+    ["compress-assets.mjs", "compress-assets.mjs"],
+    ["email-renderer.ts", "email-renderer.ts"],
+    ["email-runtime.ts", "email-runtime.ts"],
+    ["email-locales.ts", "email-locales.ts"],
+    ["tsconfig.json", "tsconfig.json"],
+    ["typecheck-loader.mjs", "typecheck-loader.mjs"],
+    ["app-config-stub.mjs", "app-config-stub.mjs"],
+    ["DmsDynamicPage.vue", "DmsDynamicPage.vue"],
+    ["server.mjs", "server.mjs"],
+    ["server", "server"],
+    ["npmrc", ".npmrc"],
+    ["pnpm-workspace.yaml", "pnpm-workspace.yaml"],
+];
+exports.LAYERS_SUBDIR = "frontend-modules";
+exports.FRONTEND_MODULE_ENTRY = "dms.frontend.ts";
+exports.LAYER_COPY_BLOCKLIST = [
+    "node_modules",
+    "dist",
+    ".git",
+    "coverage",
+    ".cache",
+    ".turbo",
+    "server",
+    "**/server",
+    "tsconfig.json",
+    "tsconfig.*.json",
+];
+exports.layerCopyIgnore = (0, ignore_1.default)().add([...exports.LAYER_COPY_BLOCKLIST]);
+exports.PNPM_LIFECYCLE_SCRIPTS = [
+    "preinstall",
+    "install",
+    "postinstall",
+    "preprepare",
+    "prepare",
+    "postprepare",
+    "prepack",
+    "postpack",
+];
+exports.TAILWIND_SOURCE_GLOB = "**/*.{vue,ts,tsx,js,jsx,mjs,cjs}";
+function booleanFromEnv(name) {
+    const value = process.env[name];
+    if (value === undefined)
+        return false;
+    return !["", "0", "false", "no", "off"].includes(value.trim().toLowerCase());
+}
+exports.Options = {
+    backendUrl: new commander_1.Option("-b, --backend-url <url>", "Backend DMS URL (when omitted, dev mode discovers it from the enclosing antelope project's .antelope/dev.json)").env("DMS_BACKEND_URL"),
+    port: new commander_1.Option("-p, --port <port>", "Port to run on")
+        .default("3001")
+        .env("PORT"),
+    force: new commander_1.Option("-f, --force", "Force reinstall dependencies"),
+    offline: new commander_1.Option("--offline", "Skip the backend manifest fetch and reuse the last cached manifest (env: DMS_OFFLINE)").default(booleanFromEnv("DMS_OFFLINE")),
+    bootstrapSecret: new commander_1.Option("--bootstrap-secret <secret>", "Credential presented to the backend's layer endpoints (env: DMS_BOOTSTRAP_SECRET, preferred — " +
+        "a secret passed on the command line is visible to every process on the machine). In dev it is " +
+        "discovered from the antelope project's .antelope/dms-dev.json.").env("DMS_BOOTSTRAP_SECRET"),
+};
+const HEADER_SAFE_CREDENTIAL = /^[\x21-\x7e]+$/;
+const DEFAULT_CREDENTIAL_SOURCE = "DMS_BOOTSTRAP_SECRET";
+function normalizeBootstrapSecret(value, source = DEFAULT_CREDENTIAL_SOURCE) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return undefined;
+    if (!HEADER_SAFE_CREDENTIAL.test(trimmed)) {
+        throw new Error("The bootstrap credential contains characters that cannot travel in an HTTP header.\n" +
+            `  Check ${source} for a line break or a non-ASCII byte — a secret read from\n` +
+            "  a file commonly keeps its trailing newline.");
+    }
+    return trimmed;
+}
+function resolveBootstrapSecret(explicit, backendUrl, options = {}) {
+    const normalized = normalizeBootstrapSecret(explicit);
+    if (normalized)
+        return normalized;
+    const result = (0, discovery_1.discoverBackend)(options.cwd ?? process.cwd(), options);
+    if (result.status !== "found")
+        return undefined;
+    if (canonicalizeBackendUrl(result.backend.backendUrl) !==
+        canonicalizeBackendUrl(backendUrl)) {
+        return undefined;
+    }
+    return normalizeBootstrapSecret((0, discovery_1.readDevBootstrapCredential)(result.backend.projectDir, options), (0, node_path_1.join)(result.backend.projectDir, discovery_1.DEV_HANDSHAKE_RELATIVE_PATH));
+}
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function canonicalizeBackendUrl(backendUrl) {
+    const raw = backendUrl.trim();
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return raw;
+    }
+    if (url.hostname === "localhost" || url.hostname === "[::1]") {
+        url.hostname = "127.0.0.1";
+    }
+    const out = url.toString();
+    if (url.pathname === "/" && !url.search && !url.hash) {
+        return out.replace(/\/$/, "");
+    }
+    return out;
+}

package/dist/discovery.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEV_HANDSHAKE_RELATIVE_PATH = exports.DEV_REGISTRY_RELATIVE_PATH = void 0;
+exports.isPidAlive = isPidAlive;
+exports.buildBackendUrl = buildBackendUrl;
+exports.discoverBackend = discoverBackend;
+exports.describeDiscoveryFailure = describeDiscoveryFailure;
+exports.readDevBootstrapCredential = readDevBootstrapCredential;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+exports.DEV_REGISTRY_RELATIVE_PATH = (0, node_path_1.join)(".antelope", "dev.json");
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err?.code === "EPERM";
+    }
+}
+function parseRegistry(file) {
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(file, "utf-8"));
+        if (typeof parsed?.pid !== "number" ||
+            typeof parsed?.servers !== "object" ||
+            parsed.servers === null) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildBackendUrl(endpoint) {
+    let host = endpoint.host;
+    if (host === "0.0.0.0" || host === "::" || host === "[::]") {
+        host = "localhost";
+    }
+    else if (host.includes(":") && !host.startsWith("[")) {
+        host = `[${host}]`;
+    }
+    return `${endpoint.protocol}://${host}:${endpoint.port}`;
+}
+function discoverBackend(cwd, options = {}) {
+    const alive = options.isPidAlive ?? isPidAlive;
+    let dir = (0, node_path_1.resolve)(cwd);
+    while (true) {
+        const file = (0, node_path_1.join)(dir, exports.DEV_REGISTRY_RELATIVE_PATH);
+        if ((0, node_fs_1.existsSync)(file)) {
+            const registry = parseRegistry(file);
+            if (!registry) {
+                return { status: "malformed", projectDir: dir };
+            }
+            if (!alive(registry.pid)) {
+                return { status: "stale", projectDir: dir, pid: registry.pid };
+            }
+            const endpoint = registry.servers.api?.endpoints?.[0];
+            if (!endpoint) {
+                return { status: "no-api-endpoint", projectDir: dir };
+            }
+            return {
+                status: "found",
+                backend: {
+                    projectDir: dir,
+                    registry,
+                    backendUrl: buildBackendUrl(endpoint),
+                },
+            };
+        }
+        const parent = (0, node_path_1.dirname)(dir);
+        if (parent === dir)
+            return { status: "not-found" };
+        dir = parent;
+    }
+}
+function describeDiscoveryFailure(result) {
+    switch (result.status) {
+        case "not-found":
+            return ("No backend URL provided and no running antelope project found.\n" +
+                `  Searched for ${exports.DEV_REGISTRY_RELATIVE_PATH} from the current directory upward.\n` +
+                "  Either run this command inside an antelope project started with 'ajs project dev',\n" +
+                "  or pass the backend explicitly with -b <url> (env: DMS_BACKEND_URL).");
+        case "stale":
+            return (`Found ${(0, node_path_1.join)(result.projectDir, exports.DEV_REGISTRY_RELATIVE_PATH)} but its process (pid ${result.pid}) is no longer running.\n` +
+                "  Start the backend with 'ajs project dev', or pass -b <url> explicitly.");
+        case "no-api-endpoint":
+            return (`Found a running antelope project at ${result.projectDir} but it exposes no 'api' server endpoint.\n` +
+                "  Make sure the api module is loaded, or pass -b <url> explicitly.");
+        case "malformed":
+            return (`Found ${(0, node_path_1.join)(result.projectDir, exports.DEV_REGISTRY_RELATIVE_PATH)} but could not parse it.\n` +
+                "  Restart the backend with 'ajs project dev' to rewrite it, or pass -b <url> explicitly.");
+        case "found":
+            return "";
+    }
+}
+exports.DEV_HANDSHAKE_RELATIVE_PATH = (0, node_path_1.join)(".antelope", "dms-dev.json");
+function parseHandshake(file) {
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(file, "utf-8"));
+        if (typeof parsed?.pid !== "number" ||
+            typeof parsed?.bootstrapSecret !== "string" ||
+            !parsed.bootstrapSecret) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readDevBootstrapCredential(projectDir, options = {}) {
+    const alive = options.isPidAlive ?? isPidAlive;
+    const file = (0, node_path_1.join)(projectDir, exports.DEV_HANDSHAKE_RELATIVE_PATH);
+    if (!(0, node_fs_1.existsSync)(file))
+        return undefined;
+    const handshake = parseHandshake(file);
+    if (!handshake || !alive(handshake.pid))
+        return undefined;
+    return handshake.bootstrapSecret;
+}

package/dist/fs-sync.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripExtendedLengthPrefix = stripExtendedLengthPrefix;
+exports.isBlocklistedCopyPath = isBlocklistedCopyPath;
+exports.sanitizedPackageContent = sanitizedPackageContent;
+exports.filesIdentical = filesIdentical;
+exports.applyContent = applyContent;
+exports.applyFile = applyFile;
+exports.collectFiles = collectFiles;
+exports.syncDirectories = syncDirectories;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const ignore_1 = __importDefault(require("ignore"));
+const config_1 = require("./config");
+function stripExtendedLengthPrefix(p) {
+    return p.replace(/^\\\\\?\\/, "");
+}
+function isBlocklistedCopyPath(src, srcPath) {
+    const rel = (0, node_path_1.relative)((0, node_path_1.resolve)(stripExtendedLengthPrefix(src)), (0, node_path_1.resolve)(stripExtendedLengthPrefix(srcPath)));
+    if (!rel || rel.startsWith(".."))
+        return false;
+    return config_1.layerCopyIgnore.ignores(rel.split(node_path_1.sep).join("/"));
+}
+function sanitizedPackageContent(raw) {
+    const pkg = JSON.parse(raw);
+    delete pkg.devDependencies;
+    if (pkg.scripts) {
+        for (const name of config_1.PNPM_LIFECYCLE_SCRIPTS) {
+            delete pkg.scripts[name];
+        }
+    }
+    return `${JSON.stringify(pkg, null, 2)}\n`;
+}
+function filesIdentical(srcPath, destPath) {
+    if (!(0, node_fs_1.existsSync)(destPath))
+        return false;
+    try {
+        const a = (0, node_fs_1.statSync)(srcPath);
+        const b = (0, node_fs_1.statSync)(destPath);
+        if (!a.isFile() || !b.isFile())
+            return false;
+        if (a.size !== b.size)
+            return false;
+        return (0, node_fs_1.readFileSync)(srcPath).equals((0, node_fs_1.readFileSync)(destPath));
+    }
+    catch {
+        return false;
+    }
+}
+function applyContent(content, destPath) {
+    const buf = Buffer.from(content);
+    if ((0, node_fs_1.existsSync)(destPath)) {
+        try {
+            if ((0, node_fs_1.readFileSync)(destPath).equals(buf))
+                return;
+        }
+        catch {
+        }
+    }
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(destPath), { recursive: true });
+    const tmp = `${destPath}.ajs-dms-tmp-${process.pid}-${Date.now()}`;
+    try {
+        (0, node_fs_1.writeFileSync)(tmp, buf);
+        (0, node_fs_1.renameSync)(tmp, destPath);
+    }
+    finally {
+        if ((0, node_fs_1.existsSync)(tmp))
+            (0, node_fs_1.rmSync)(tmp, { force: true });
+    }
+}
+function applyFile(srcPath, destPath) {
+    if (filesIdentical(srcPath, destPath))
+        return;
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(destPath), { recursive: true });
+    const tmp = `${destPath}.ajs-dms-tmp-${process.pid}-${Date.now()}`;
+    try {
+        (0, node_fs_1.cpSync)(srcPath, tmp, { force: true, dereference: true });
+        (0, node_fs_1.renameSync)(tmp, destPath);
+    }
+    finally {
+        if ((0, node_fs_1.existsSync)(tmp))
+            (0, node_fs_1.rmSync)(tmp, { force: true });
+    }
+}
+function loadGitignore(layerPath) {
+    const ig = (0, ignore_1.default)();
+    const gitignorePath = (0, node_path_1.join)(layerPath, ".gitignore");
+    if ((0, node_fs_1.existsSync)(gitignorePath)) {
+        ig.add((0, node_fs_1.readFileSync)(gitignorePath, "utf-8"));
+    }
+    return ig;
+}
+function collectFiles(dir, baseDir = dir) {
+    const files = [];
+    if (!(0, node_fs_1.existsSync)(dir))
+        return files;
+    const entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = (0, node_path_1.join)(dir, entry.name);
+        const { relative } = require("node:path");
+        const relPath = relative(baseDir, fullPath);
+        if (entry.isDirectory()) {
+            files.push(...collectFiles(fullPath, baseDir));
+        }
+        else {
+            files.push(relPath);
+        }
+    }
+    return files;
+}
+function syncDirectories(src, dest) {
+    const ig = loadGitignore(src);
+    const srcFiles = collectFiles(src).filter((f) => !ig.ignores(f));
+    const destFiles = collectFiles(dest);
+    for (const file of srcFiles) {
+        applyFile((0, node_path_1.join)(src, file), (0, node_path_1.join)(dest, file));
+    }
+    for (const file of destFiles) {
+        if (ig.ignores(file))
+            continue;
+        if (!srcFiles.includes(file)) {
+            (0, node_fs_1.rmSync)((0, node_path_1.join)(dest, file), { force: true });
+        }
+    }
+    cleanEmptyDirs(dest);
+}
+function cleanEmptyDirs(dir) {
+    const { statSync } = require("node:fs");
+    if (!(0, node_fs_1.existsSync)(dir) || !statSync(dir).isDirectory())
+        return;
+    for (const entry of (0, node_fs_1.readdirSync)(dir)) {
+        const full = (0, node_path_1.join)(dir, entry);
+        if (statSync(full).isDirectory())
+            cleanEmptyDirs(full);
+    }
+    if ((0, node_fs_1.readdirSync)(dir).length === 0) {
+        (0, node_fs_1.rmSync)(dir, { recursive: true, force: true });
+    }
+}

package/dist/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const build_1 = require("./commands/build");
+const clean_1 = require("./commands/clean");
+const dev_1 = require("./commands/dev");
+const prepare_1 = require("./commands/prepare");
+const start_1 = require("./commands/start");
+const verify_source_1 = require("./commands/verify-source");
+const update_check_1 = require("./update-check");
+const cli_ui_1 = require("./utils/cli-ui");
+const { version } = require("../package.json");
+const runCLI = async () => {
+    const argv = process.argv.slice(2);
+    void (0, update_check_1.checkForUpdate)({ currentVersion: version, argv });
+    if (process.argv.length <= 2) {
+        (0, cli_ui_1.displayBanner)("Antelope DMS");
+        console.log(chalk_1.default.dim(`  Frontend Loader for AntelopeJS DMS - v${version}\n`));
+    }
+    const program = new commander_1.Command()
+        .name("ajs-dms")
+        .description(`Antelope DMS - Frontend Loader v${version}\n\n` +
+        `Materializes frontend modules from an AntelopeJS backend and starts a Vue or React Vite and Inertia application.`)
+        .version(version, "-v, --version", "Display version number")
+        .option("--no-update-check", "Skip the daily check for a newer DMS frontend release")
+        .helpCommand("help [command]", "Display help for a specific command");
+    program.addCommand((0, dev_1.cmdDev)());
+    program.addCommand((0, build_1.cmdBuild)());
+    program.addCommand((0, start_1.cmdStart)());
+    program.addCommand((0, prepare_1.cmdPrepare)());
+    program.addCommand((0, clean_1.cmdClean)());
+    program.addCommand((0, verify_source_1.cmdVerifySource)());
+    await program.parseAsync((0, update_check_1.stripUpdateCheckFlag)(argv), { from: "user" });
+};
+process.on("SIGINT", () => process.exit(0));
+runCLI().catch((err) => {
+    console.error(chalk_1.default.red("Error:"), err.message || err);
+    process.exit(1);
+});

package/dist/layer-watch.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startLayerWatchers = startLayerWatchers;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const chokidar_1 = __importDefault(require("chokidar"));
+const layers_1 = require("./layers");
+const fs_sync_1 = require("./fs-sync");
+const WATCH_DEBOUNCE_MS = 80;
+function createLayerSync(src, dest) {
+    const fileUpserts = new Set();
+    const fileDeletes = new Set();
+    const dirCreates = new Set();
+    const dirDeletes = new Set();
+    let timer = null;
+    const toRel = (p) => {
+        const r = (0, node_path_1.relative)(src, p);
+        return r ? r : null;
+    };
+    const warnFailure = (rel, err) => {
+        console.warn(`[ajs-dms] layer sync skipped ${rel}:`, err);
+    };
+    const flush = () => {
+        timer = null;
+        for (const rel of [...dirCreates].sort((a, b) => a.length - b.length)) {
+            try {
+                (0, node_fs_1.mkdirSync)((0, node_path_1.join)(dest, rel), { recursive: true });
+            }
+            catch (err) {
+                warnFailure(rel, err);
+            }
+        }
+        dirCreates.clear();
+        for (const rel of fileUpserts) {
+            try {
+                const srcPath = (0, node_path_1.join)(src, rel);
+                if (!(0, node_fs_1.existsSync)(srcPath))
+                    continue;
+                const destPath = (0, node_path_1.join)(dest, rel);
+                if (rel === "package.json") {
+                    (0, fs_sync_1.applyContent)((0, fs_sync_1.sanitizedPackageContent)((0, node_fs_1.readFileSync)(srcPath, "utf-8")), destPath);
+                }
+                else {
+                    (0, fs_sync_1.applyFile)(srcPath, destPath);
+                }
+            }
+            catch (err) {
+                warnFailure(rel, err);
+            }
+        }
+        fileUpserts.clear();
+        for (const rel of fileDeletes) {
+            try {
+                if ((0, node_fs_1.existsSync)((0, node_path_1.join)(src, rel)))
+                    continue;
+                const destPath = (0, node_path_1.join)(dest, rel);
+                if ((0, node_fs_1.existsSync)(destPath))
+                    (0, node_fs_1.rmSync)(destPath, { force: true });
+            }
+            catch (err) {
+                warnFailure(rel, err);
+            }
+        }
+        fileDeletes.clear();
+        for (const rel of [...dirDeletes].sort((a, b) => b.length - a.length)) {
+            try {
+                if ((0, node_fs_1.existsSync)((0, node_path_1.join)(src, rel)))
+                    continue;
+                const destPath = (0, node_path_1.join)(dest, rel);
+                if ((0, node_fs_1.existsSync)(destPath))
+                    (0, node_fs_1.rmSync)(destPath, { recursive: true, force: true });
+            }
+            catch (err) {
+                warnFailure(rel, err);
+            }
+        }
+        dirDeletes.clear();
+    };
+    const arm = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(flush, WATCH_DEBOUNCE_MS);
+    };
+    return {
+        upsertFile(p) {
+            const r = toRel(p);
+            if (!r)
+                return;
+            fileDeletes.delete(r);
+            fileUpserts.add(r);
+            arm();
+        },
+        deleteFile(p) {
+            const r = toRel(p);
+            if (!r)
+                return;
+            fileUpserts.delete(r);
+            fileDeletes.add(r);
+            arm();
+        },
+        createDir(p) {
+            const r = toRel(p);
+            if (!r)
+                return;
+            dirDeletes.delete(r);
+            dirCreates.add(r);
+            arm();
+        },
+        deleteDir(p) {
+            const r = toRel(p);
+            if (!r)
+                return;
+            dirCreates.delete(r);
+            dirDeletes.add(r);
+            arm();
+        },
+        flushNow() {
+            if (timer)
+                clearTimeout(timer);
+            flush();
+        },
+    };
+}
+function startLayerWatchers(workspaceDir, layers) {
+    const watchers = [];
+    const syncs = [];
+    for (const layer of layers) {
+        if (!layer.packageName)
+            continue;
+        const dest = (0, layers_1.getLayerWorkspacePath)(workspaceDir, layer);
+        const src = layer.path;
+        const sync = createLayerSync(src, dest);
+        syncs.push(sync);
+        const watcher = chokidar_1.default.watch(src, {
+            ignoreInitial: true,
+            ignored: (path) => (0, fs_sync_1.isBlocklistedCopyPath)(src, path),
+            persistent: true,
+        });
+        watcher.on("add", (p) => sync.upsertFile(p));
+        watcher.on("change", (p) => sync.upsertFile(p));
+        watcher.on("unlink", (p) => sync.deleteFile(p));
+        watcher.on("addDir", (p) => sync.createDir(p));
+        watcher.on("unlinkDir", (p) => sync.deleteDir(p));
+        watchers.push(watcher);
+    }
+    return async () => {
+        await Promise.all(watchers.map((w) => w.close().catch(() => { })));
+        for (const sync of syncs)
+            sync.flushNow();
+    };
+}