@antelopejs/dms 0.11.0 → 0.12.0

package/frontend-vue/scripts/check-invariants.mjs

@@ -0,0 +1,356 @@
+import assert from "node:assert/strict";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { brotliDecompressSync } from "node:zlib";
+import { z } from "zod";
+import "./check-autoimport-boundaries.mjs";
+import "./test-autoimport-boundaries.mjs";
+import "./check-page-invariants.mjs";
+import "../../../../checks/notification-tone-contract.mjs";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const LAYERS_DIR = join(ROOT, "layers");
+
+function collectSources(dir) {
+  return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const file = join(dir, entry.name);
+    if (entry.name === "node_modules" || entry.name.startsWith(".")) return [];
+    if (entry.isDirectory()) return collectSources(file);
+    return /\.(vue|ts)$/.test(entry.name) ? [file] : [];
+  });
+}
+
+const sources = collectSources(LAYERS_DIR).map((file) => ({
+  file,
+  source: readFileSync(file, "utf8"),
+}));
+
+function checkAccessibleNames() {
+  const literals = sources.flatMap(({ file, source }) =>
+    file.endsWith(".vue")
+      ? [
+          ...source.matchAll(
+            /\s(?:aria-label|title)\s*=\s*(?:"[A-Za-z][^"{]*"|'[A-Za-z][^'{]*')/g,
+          ),
+        ].map((match) => `${relative(LAYERS_DIR, file)}:${match[0].trim()}`)
+      : [],
+  );
+  assert.deepEqual(
+    literals,
+    [],
+    "Bind aria-label and title to translated text",
+  );
+}
+
+function checkPluginRegistration() {
+  const manifests = ["dms.frontend.ts", "deferred-plugins.ts"]
+    .map((file) => readFileSync(join(ROOT, file), "utf8"))
+    .join("\n");
+  const missing = [];
+  for (const layer of readdirSync(LAYERS_DIR)) {
+    const pluginsDir = join(LAYERS_DIR, layer, "app/plugins");
+    if (!existsSync(pluginsDir)) continue;
+    for (const file of readdirSync(pluginsDir).filter((name) =>
+      name.endsWith(".ts"),
+    )) {
+      const plugin = `./layers/${layer}/app/plugins/${file.replace(/\.ts$/, "")}`;
+      if (!manifests.includes(`"${plugin}"`)) missing.push(plugin);
+    }
+  }
+  assert.deepEqual(
+    missing,
+    [],
+    "Register layer plugins in a frontend manifest",
+  );
+}
+
+function checkCompareModeLabels() {
+  const source = readFileSync(
+    resolve(ROOT, "../../interface-dms/src/base/data-types/compare-types.ts"),
+    "utf8",
+  );
+  const modes = [
+    ...source.matchAll(/@RegisterDataCompareMode\(\s*"([a-z_]+)"/g),
+  ].map(([, id]) => id);
+  assert.ok(
+    modes.length > 0,
+    "No compare modes found in the interface registry",
+  );
+  const missing = [];
+  for (const locale of ["en-GB", "fr-FR"]) {
+    const messages = JSON.parse(
+      readFileSync(
+        join(LAYERS_DIR, `dms-ui/i18n/locales/ui-${locale}.json`),
+        "utf8",
+      ),
+    );
+    for (const mode of modes) {
+      if (!messages.dms.table.compare_mode[mode])
+        missing.push(`${locale}:${mode}`);
+    }
+  }
+  assert.deepEqual(missing, [], "Translate every registered compare mode");
+}
+
+function checkFormErrorSummaryLabels() {
+  for (const locale of ["en-GB", "fr-FR"]) {
+    const messages = JSON.parse(
+      readFileSync(
+        join(LAYERS_DIR, `dms-ui/i18n/locales/ui-${locale}.json`),
+        "utf8",
+      ),
+    );
+    const resolved = messages.dms?.form?.error_summary?.resolved;
+    assert.ok(
+      z.string().regex(/\S/).safeParse(resolved).success,
+      `${locale}: translate dms.form.error_summary.resolved`,
+    );
+  }
+}
+
+function messageKeys(messages, prefix = "") {
+  return Object.entries(messages).flatMap(([key, value]) => {
+    const path = prefix ? `${prefix}.${key}` : key;
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+      ? messageKeys(value, path)
+      : [path];
+  });
+}
+
+function checkLocaleKeyParity() {
+  const gaps = [];
+  for (const layer of readdirSync(LAYERS_DIR)) {
+    const dir = join(LAYERS_DIR, layer, "i18n/locales");
+    if (!existsSync(dir)) continue;
+    const catalogs = readdirSync(dir)
+      .filter((name) => name.endsWith(".json"))
+      .map((name) => ({
+        name,
+        keys: new Set(
+          messageKeys(JSON.parse(readFileSync(join(dir, name), "utf8"))),
+        ),
+      }));
+    for (const { name, keys } of catalogs) {
+      for (const other of catalogs) {
+        for (const key of other.keys) {
+          if (!keys.has(key)) gaps.push(`${layer}/${name}: ${key}`);
+        }
+      }
+    }
+  }
+  assert.deepEqual(gaps, [], "Translate every key in every locale of a layer");
+}
+
+function staticPrefix(key, source) {
+  const resolved = key.replace(/\$\{(\w+)\}/g, (interpolation, name) => {
+    const declaration = source.match(
+      new RegExp(`\\bconst ${name} = ("[^"]*"|'[^']*'|\`[^\`$]*\`)`),
+    );
+    return declaration ? declaration[1].slice(1, -1) : interpolation;
+  });
+  return resolved.split("${")[0] ?? "";
+}
+
+function checkAsyncDataKeyOwners() {
+  const owners = new Map();
+  for (const { file, source } of sources) {
+    for (const match of source.matchAll(
+      /useDms(?:Lazy)?AsyncData\(\s*(?:`([^`]*)`|"([^"]*)"|'([^']*)')/g,
+    )) {
+      const prefix = staticPrefix(
+        match[1] ?? match[2] ?? match[3] ?? "",
+        source,
+      );
+      if (!prefix) continue;
+      const files = owners.get(prefix) ?? new Set();
+      files.add(relative(LAYERS_DIR, file));
+      owners.set(prefix, files);
+    }
+  }
+  const shared = [...owners]
+    .filter(([, files]) => files.size > 1)
+    .map(([prefix, files]) => `${prefix} -> ${[...files].join(", ")}`);
+  assert.deepEqual(
+    shared,
+    [],
+    "Declare each async data key prefix in one file",
+  );
+}
+
+function checkAsyncDataScopeRegistration() {
+  assert.match(
+    readFileSync(join(ROOT, "dms.frontend.ts"), "utf8"),
+    /registerPlugin\(asyncDataScopePlugin, \{ enforce: "pre" \}\)/,
+    "Register asyncDataScopePlugin with enforce pre before module plugins read data",
+  );
+}
+
+function checkFontAssetUrls() {
+  const stylesheet = join(
+    LAYERS_DIR,
+    "dms-layout/app/assets/css/foundation.css",
+  );
+  const urls = [
+    ...readFileSync(stylesheet, "utf8").matchAll(
+      /@font-face\s*{[^}]*?src:\s*url\("([^"]+)"\)/g,
+    ),
+  ].map(([, url]) => url);
+  assert.ok(
+    urls.length > 0,
+    "No font-face URLs found in the layout stylesheet",
+  );
+  for (const url of urls) {
+    assert.doesNotMatch(
+      url,
+      /^(?:\/|[a-z][a-z\d+.-]*:)/i,
+      `${url} must be a relative font asset URL`,
+    );
+    assert.ok(
+      existsSync(resolve(dirname(stylesheet), url)),
+      `${url} must resolve to a bundled font asset`,
+    );
+  }
+}
+
+function checkOnboardingPageMeta() {
+  assert.match(
+    readFileSync(
+      join(LAYERS_DIR, "dms-onboarding/app/custom-pages/onboarding.vue"),
+      "utf8",
+    ),
+    /defineDmsPageMeta\(/,
+    "Declare onboarding page meta so global middleware runs on direct loads",
+  );
+}
+
+const KNOWN_TAGS =
+  "cmap head hhea hmtx maxp name OS/2 post cvt_ fpgm glyf loca prep CFF_ VORG EBDT EBLC gasp hdmx kern LTSH PCLT VDMX vhea vmtx BASE GDEF GPOS GSUB EBSC JSTF MATH CBDT CBLC COLR CPAL SVG_ sbix acnt avar bdat bloc bsln cvar fdsc feat fmtx fvar gvar hsty just lcar mort morx opbd prop trak Zapf Silf Glat Gloc Feat Sill"
+    .split(" ")
+    .map((tag) => tag.replace("_", " "));
+const HEADER_SIZE = 48;
+const NUM_TABLES_OFFSET = 12;
+const CUSTOM_TAG_INDEX = 63;
+const TAG_INDEX_MASK = 0x3f;
+const TRANSFORM_SHIFT = 6;
+const UNICODE_PLATFORM = 0;
+const WINDOWS_PLATFORM = 3;
+const WINDOWS_UNICODE_BMP = 1;
+const SEGMENT_MAPPING_FORMAT = 4;
+
+function readBase128(data, cursor) {
+  let value = 0;
+  for (;;) {
+    const byte = data[cursor.at++];
+    assert.notEqual(byte, undefined, "Truncated WOFF2 table directory");
+    value = value * 128 + (byte & 0x7f);
+    if (!(byte & 0x80)) return value;
+  }
+}
+
+function readCmap(file) {
+  const numTables = file.readUInt16BE(NUM_TABLES_OFFSET);
+  const cursor = { at: HEADER_SIZE };
+  const tables = [];
+  for (let index = 0; index < numTables; index++) {
+    const flags = file[cursor.at++];
+    const tagIndex = flags & TAG_INDEX_MASK;
+    let tag = KNOWN_TAGS[tagIndex] ?? "";
+    if (tagIndex === CUSTOM_TAG_INDEX) {
+      tag = file.toString("latin1", cursor.at, cursor.at + 4);
+      cursor.at += 4;
+    }
+    const transform = flags >> TRANSFORM_SHIFT;
+    const originalLength = readBase128(file, cursor);
+    const isTransformed =
+      tag === "glyf" || tag === "loca" ? transform === 0 : transform !== 0;
+    const length = isTransformed ? readBase128(file, cursor) : originalLength;
+    tables.push({ tag, length });
+  }
+  const data = brotliDecompressSync(file.subarray(cursor.at));
+  let offset = 0;
+  for (const table of tables) {
+    if (table.tag === "cmap")
+      return data.subarray(offset, offset + table.length);
+    offset += table.length;
+  }
+  throw new Error("no cmap table");
+}
+
+function glyphOf(cmap, codePoint) {
+  const count = cmap.readUInt16BE(2);
+  for (let index = 0; index < count; index++) {
+    const record = 4 + index * 8;
+    const platform = cmap.readUInt16BE(record);
+    const encoding = cmap.readUInt16BE(record + 2);
+    const subtable = cmap.subarray(cmap.readUInt32BE(record + 4));
+    const isUnicode =
+      platform === UNICODE_PLATFORM ||
+      (platform === WINDOWS_PLATFORM && encoding === WINDOWS_UNICODE_BMP);
+    if (!isUnicode || subtable.readUInt16BE(0) !== SEGMENT_MAPPING_FORMAT)
+      continue;
+    const segments = subtable.readUInt16BE(6) / 2;
+    const ends = 14;
+    const starts = ends + segments * 2 + 2;
+    const deltas = starts + segments * 2;
+    const rangeOffsets = deltas + segments * 2;
+    for (let segment = 0; segment < segments; segment++) {
+      const end = subtable.readUInt16BE(ends + segment * 2);
+      if (codePoint > end) continue;
+      const start = subtable.readUInt16BE(starts + segment * 2);
+      if (codePoint < start) return 0;
+      const delta = subtable.readUInt16BE(deltas + segment * 2);
+      const rangeOffsetAt = rangeOffsets + segment * 2;
+      const rangeOffset = subtable.readUInt16BE(rangeOffsetAt);
+      if (rangeOffset === 0) return (codePoint + delta) & 0xffff;
+      const glyph = subtable.readUInt16BE(
+        rangeOffsetAt + rangeOffset + (codePoint - start) * 2,
+      );
+      return glyph === 0 ? 0 : (glyph + delta) & 0xffff;
+    }
+    return 0;
+  }
+  throw new Error("no Unicode BMP subtable");
+}
+
+function checkGeistNarrowSpace() {
+  for (const name of [
+    "Geist-Variable.woff2",
+    "Geist-Italic-Variable.woff2",
+    "GeistMono-Variable.woff2",
+    "GeistMono-Italic-Variable.woff2",
+  ]) {
+    const cmap = readCmap(
+      readFileSync(join(LAYERS_DIR, "dms-layout/app/assets/fonts", name)),
+    );
+    const noBreakSpace = glyphOf(cmap, 0xa0);
+    assert.notEqual(noBreakSpace, 0, `${name} has no no-break space glyph`);
+    assert.equal(
+      glyphOf(cmap, 0x202f),
+      noBreakSpace,
+      `${name} must map U+202F to its no-break space glyph`,
+    );
+  }
+}
+
+for (const [name, check] of [
+  ["translated accessible names", checkAccessibleNames],
+  ["layer plugin registration", checkPluginRegistration],
+  ["compare mode labels", checkCompareModeLabels],
+  ["form error summary labels", checkFormErrorSummaryLabels],
+  ["locale key parity", checkLocaleKeyParity],
+  ["async data key ownership", checkAsyncDataKeyOwners],
+  ["async data scope registration", checkAsyncDataScopeRegistration],
+  ["Geist narrow no-break spaces", checkGeistNarrowSpace],
+  ["font asset URLs", checkFontAssetUrls],
+  ["onboarding page meta", checkOnboardingPageMeta],
+]) {
+  try {
+    check();
+    console.log(`PASS ${name}`);
+  } catch (error) {
+    console.error(`FAIL ${name}`);
+    console.error(error);
+    process.exitCode = 1;
+  }
+}

package/frontend-vue/scripts/check-page-invariants.mjs

@@ -0,0 +1,279 @@
+import assert from "node:assert/strict";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { registerHooks } from "node:module";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const layers = join(root, "layers");
+const read = (path) => readFileSync(join(layers, path), "utf8");
+
+function files(dir) {
+  return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(dir, entry.name);
+    return entry.isDirectory() ? files(path) : [path];
+  });
+}
+
+function checkInstantSavePages() {
+  const settings = "dms-layout/app/custom-pages/settings";
+  const parts = "dms-layout/app/build/components/pages/settings";
+  const form = "dms-ui/app/components/form/Form.vue";
+  const instantSave = [
+    `${parts}/theme/useAppearanceSave.ts`,
+    `${parts}/notification/NotificationPreferencesForm.vue`,
+    form,
+  ];
+  const noPill = [
+    `${settings}/roles.vue`,
+    `${settings}/shortcuts.vue`,
+    `${parts}/profile/ProfilePersonalInfo.vue`,
+    `${parts}/roles/RoleEditor.vue`,
+  ];
+  for (const path of instantSave) {
+    assert.match(read(path), /useInstantSaveHeader\(/, path);
+  }
+  for (const path of noPill) {
+    assert.doesNotMatch(read(path), /useInstantSaveHeader/, path);
+  }
+  const components = files(layers)
+    .filter((path) => path.endsWith(".vue"))
+    .map((path) => ({
+      path: relative(layers, path).replaceAll("\\", "/"),
+      source: readFileSync(path, "utf8"),
+    }));
+  const users = components.filter(({ source }) =>
+    /useInstantSaveHeader\(/.test(source),
+  );
+  assert.deepEqual(
+    users.map(({ path }) => path).sort(),
+    instantSave.filter((path) => path.endsWith(".vue")).sort(),
+    "instant-save page registry",
+  );
+  for (const { path, source } of users) {
+    if (path !== form) assert.doesNotMatch(source, /DmsSaveBar|saveBar/, path);
+  }
+  assert.match(read(form), /if \(instantSave && /, "instant-save form mode");
+}
+
+function checkServerRouteOwnership() {
+  const entry = readFileSync(join(root, "dms.server.ts"), "utf8");
+  const routes = [
+    ...entry.matchAll(/registerRoute\(\s*"[A-Z]+",\s*"([^"]+)"/g),
+  ].map((match) => match[1]);
+  const pages = files(resolve(root, "../src/pages/public")).flatMap((path) => {
+    const slug = /urlSlug:\s*"([^"]+)"/.exec(readFileSync(path, "utf8"));
+    return slug ? [`/${slug[1]}`] : [];
+  });
+  assert.ok(routes.length > 0, "server route registry must not be empty");
+  assert.ok(pages.includes("/auth/signup"), "public signup page must be found");
+  assert.deepEqual(
+    routes.filter((path) => pages.includes(path)),
+    [],
+    "server routes must not shadow public pages",
+  );
+}
+
+function checkSortableDependency() {
+  const manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+  assert.ok(!Object.hasOwn(manifest.dependencies, "vuedraggable"));
+  assert.ok(Object.hasOwn(manifest.dependencies, "sortablejs"));
+}
+
+function readLocale(layer, prefix, locale) {
+  return JSON.parse(read(`${layer}/i18n/locales/${prefix}-${locale}.json`));
+}
+
+function checkFormLoadErrorLabels() {
+  const keys = [
+    "error_description",
+    "error_title",
+    "forbidden_description",
+    "forbidden_title",
+    "missing_description",
+    "missing_title",
+    "not_found_description",
+    "not_found_title",
+    "retry",
+  ];
+  for (const locale of ["en-GB", "fr-FR"]) {
+    const messages = readLocale("dms-ui", "ui", locale);
+    assert.deepEqual(
+      Object.keys(messages.dms.form.load_error).sort(),
+      keys,
+      `${locale} form load error labels`,
+    );
+  }
+}
+
+async function checkShortcutTranslations() {
+  const hook = registerHooks({
+    resolve(specifier, context, nextResolve) {
+      if (specifier.startsWith(".") && context.parentURL?.startsWith("file:")) {
+        const base = fileURLToPath(new URL(specifier, context.parentURL));
+        for (const path of [`${base}.ts`, join(base, "index.ts")]) {
+          if (existsSync(path)) {
+            return nextResolve(pathToFileURL(path).href, context);
+          }
+        }
+      }
+      return nextResolve(specifier, context);
+    },
+  });
+  try {
+    const { default: registry } = await import(
+      "../layers/dms-ui/app/config/shortcuts-registry.ts"
+    );
+    const {
+      GLOBAL_SLASH_METADATA,
+      GLOBAL_META_SLASH_METADATA,
+      NAV_SEARCH_SHORTCUT,
+      PAGE_SEARCH_HINT_KEYS,
+    } = await import(
+      "../layers/dms-ui/app/entries/composables/global/searchShortcuts"
+    );
+    assert.deepEqual(GLOBAL_SLASH_METADATA.key, [NAV_SEARCH_SHORTCUT]);
+    assert.deepEqual(
+      GLOBAL_META_SLASH_METADATA.key,
+      PAGE_SEARCH_HINT_KEYS.map((key) =>
+        key === "meta" ? "$keyboard.meta" : key,
+      ),
+      "displayed search shortcut matches the input hint",
+    );
+    const search = [GLOBAL_SLASH_METADATA, GLOBAL_META_SLASH_METADATA];
+    const global = registry.find((group) => group.component === "Global");
+    for (const metadata of search) {
+      assert.ok(
+        global?.shortcuts.includes(metadata),
+        "search shortcut registration",
+      );
+    }
+    const signature = (keys) => keys.join("+").toLowerCase();
+    const keys = search.map((metadata) => signature(metadata.key));
+    const clashes = registry
+      .flatMap((group) => group.shortcuts)
+      .filter(
+        (shortcut) =>
+          !search.includes(shortcut) && keys.includes(signature(shortcut.key)),
+      );
+    assert.deepEqual(clashes, [], "search shortcut key conflicts");
+    for (const locale of ["en-GB", "fr-FR"]) {
+      const messages = readLocale("dms-ui", "ui", locale);
+      const lookup = (key) =>
+        key
+          .slice(1)
+          .split(".")
+          .reduce((value, part) => value?.[part], messages);
+      for (const metadata of [
+        GLOBAL_SLASH_METADATA,
+        GLOBAL_META_SLASH_METADATA,
+      ]) {
+        for (const item of [metadata, metadata.condition]) {
+          assert.match(
+            lookup(item.descriptionKey),
+            /^/,
+            `${locale} ${item.descriptionKey}`,
+          );
+        }
+      }
+      const groups = readLocale("dms-layout", "layout", locale).page.settings
+        .shortcuts.groups;
+      for (const { component } of registry) {
+        const group = groups[component.toLowerCase()];
+        assert.match(group?.title, /^/, `${locale} ${component} title`);
+        assert.match(
+          group?.description,
+          /^/,
+          `${locale} ${component} description`,
+        );
+      }
+    }
+  } finally {
+    hook.deregister();
+  }
+}
+
+function checkLiveLabels() {
+  for (const locale of ["en-GB", "fr-FR"]) {
+    const live = readLocale("dms-ui", "ui", locale).dms.live;
+    for (const key of [
+      "direct",
+      "paused",
+      "resume",
+      "reason_hidden",
+      "polling",
+      "table_held",
+      "held_row_open",
+      "held_searching",
+      "held_sorted",
+      "held_scrolled",
+    ]) {
+      assert.ok(live[key], `${locale} ${key}`);
+    }
+  }
+}
+
+async function checkPeriodLabels() {
+  const { PRESET_SHORT_LABELS } = await import(
+    "../layers/dms-ui/app/entries/composables/period/periodShortLabels.ts"
+  );
+  const source = readFileSync(
+    resolve(root, "../../interface-dms/src/base/period-selector.ts"),
+    "utf8",
+  );
+  const declaration =
+    /export const PERIOD_PRESETS = \[([\s\S]*?)\] as const/.exec(source);
+  assert.ok(declaration, "period preset registry must be found");
+  const presets = [...declaration[1].matchAll(/"([^"]+)"/g)].map(
+    (match) => match[1],
+  );
+  assert.ok(presets.length > 0, "period preset registry must not be empty");
+  assert.deepEqual(
+    presets.filter(
+      (preset) => preset !== "custom" && !PRESET_SHORT_LABELS[preset],
+    ),
+    [],
+    "every non-custom period needs a short code",
+  );
+  for (const locale of ["en-GB", "fr-FR"]) {
+    const labels = readLocale("dms-core", "core", locale).dms.period
+      .short_presets;
+    assert.deepEqual(
+      Object.keys(labels).sort(),
+      Object.keys(PRESET_SHORT_LABELS).sort(),
+      `${locale} period short codes`,
+    );
+    assert.deepEqual(
+      Object.values(labels).filter((code) => /^\p{L}$/u.test(code)),
+      [],
+      `${locale} period codes must not be bare letters`,
+    );
+  }
+}
+
+function checkDevelopmentPlugin() {
+  const entry = readFileSync(join(root, "dms.frontend.ts"), "utf8");
+  const development = /if \(import\.meta\.env\.DEV\) \{([\s\S]*?)\n {2}\}/.exec(
+    entry,
+  );
+  assert.ok(development, "development plugin scope");
+  assert.match(
+    development[1],
+    /import\(\s*"\.\/layers\/dms-core\/app\/plugins\/dev-error-log"\s*\)[\s\S]*?\{ \.\.\.clientOnly, enforce: "pre" \}/,
+    "development logger is browser-only and runs before other plugins",
+  );
+}
+
+for (const [name, check] of [
+  ["instant-save page registry", checkInstantSavePages],
+  ["server route ownership", checkServerRouteOwnership],
+  ["sortable dependency", checkSortableDependency],
+  ["form load error labels", checkFormLoadErrorLabels],
+  ["shortcut translations", checkShortcutTranslations],
+  ["live labels", checkLiveLabels],
+  ["period short codes", checkPeriodLabels],
+  ["development plugin registration", checkDevelopmentPlugin],
+]) {
+  await check();
+  console.log(`PASS ${name}`);
+}

package/frontend-vue/scripts/probes/capture-frontend-probe.cjs

@@ -0,0 +1,21 @@
+"use strict";
+
+const path = require("node:path");
+const { createRequire } = require("node:module");
+const viteRequire = createRequire(require.resolve("vite/package.json"));
+const { buildSync } = viteRequire("esbuild");
+
+function captureProbe(outfile) {
+  buildSync({
+    entryPoints: [path.join(__dirname, "frontend-behavior.cjs")],
+    outfile,
+    bundle: true,
+    platform: "node",
+    format: "cjs",
+    logLevel: "silent",
+  });
+}
+
+module.exports = { captureProbe };
+
+if (require.main === module) captureProbe(path.resolve(process.argv[2]));