@_linked/cli 1.46.2 → 1.47.1

package/hooks/lock-at-rest.cjs

@@ -0,0 +1,268 @@
+// Keeps the committed package-lock.json clean at rest while checkouts in packages-local/* are
+// workspace members. With them present npm rewrites the lockfile to list them; the committed one
+// must stay the registry lockfile. The app's `postinstall` and `dependencies` scripts run it
+// through a guard that does nothing when the cli is not installed (`npm ci --omit=dev`):
+//   node -e "const p='node_modules/@_linked/cli/hooks/lock-at-rest.cjs';require('fs').existsSync(p)&&require(require('path').resolve(p))"
+// so it runs when required as well as when run as `node lock-at-rest.cjs`. It is plain, unbuilt
+// CommonJS with Node built-ins only: it must work when the cli is a fresh checkout without lib/,
+// and it never needs the `linked` binary to exist.
+//
+// It never fails the install: no git, not a work tree, git refusing (safe.directory in Docker), no
+// HEAD yet -- all leave the lockfile as npm wrote it.
+'use strict';
+const {execFileSync} = require('child_process');
+const {createHash} = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const {
+  LEAK,
+  LOCAL_DIR,
+  localMembers,
+  manifestPathspecs,
+} = require('./manifests.cjs');
+const {hookLine, runsOurHook} = require('./hook-shim.cjs');
+const {terminalDevice} = require('./platform.cjs');
+
+// An app's lockfile is often over a megabyte, execFileSync's default buffer.
+const MAX_BUFFER = 256 * 1024 * 1024;
+const LOCKFILE = 'package-lock.json';
+const ADVICE =
+  'To change dependencies: npx linked delocalize, npm install <dep>, commit, then npx linked localize --parked.';
+// Where an interrupted first set-up leaves the checkouts: SETUP_ASIDE_DIR in src/localize/localize.ts.
+const SETUP_ASIDE = `${LOCAL_DIR}/.setup-aside`;
+
+function run() {
+  // npm runs lifecycle scripts from the package root: the app, which may sit below the git top
+  // level. (__dirname is no guide: a localized cli resolves to its checkout.)
+  const root = process.cwd();
+
+  // npm pipes (and hides) the output of the `dependencies` script, so also write to the terminal,
+  // opened the first time there is something to say.
+  let tty;
+  function write(text) {
+    process.stderr.write(text);
+    if (process.env.npm_lifecycle_event !== 'dependencies') return;
+    if (tty === undefined) {
+      const device = terminalDevice();
+      try {
+        // Windows has no such device: there, only stderr (hidden by npm for this script).
+        tty = device ? fs.openSync(device, 'w') : null;
+      } catch {
+        tty = null;
+      }
+    }
+    if (tty === null) return;
+    try {
+      fs.writeSync(tty, text);
+    } catch {
+      /* the terminal went away; stderr has it */
+    }
+  }
+  const say = (m) => write(`[lock-at-rest] ${m}\n`);
+
+  function git(...args) {
+    return execFileSync('git', args, {
+      cwd: root,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      maxBuffer: MAX_BUFFER,
+    });
+  }
+
+  /** The staged lockfile, or null when the index has none (or git cannot say). */
+  function staged() {
+    try {
+      return git('show', `:./${LOCKFILE}`);
+    } catch {
+      return null;
+    }
+  }
+
+  function restore(members) {
+    let changed, lockDirty;
+    try {
+      if (git('rev-parse', '--is-inside-work-tree').trim() !== 'true') return;
+      // A changed manifest means the developer is changing dependencies: leave the lockfile alone.
+      changed = git(
+        'diff',
+        '--name-only',
+        '--relative',
+        'HEAD',
+        '--',
+        ...manifestPathspecs(root),
+      ).trim();
+      // Tracked and different from HEAD; an app that does not commit its lockfile has nothing to restore.
+      lockDirty = git(
+        'diff',
+        '--name-only',
+        '--relative',
+        'HEAD',
+        '--',
+        LOCKFILE,
+      ).trim();
+    } catch {
+      return; // no git, not a work tree, no HEAD, or git refused
+    }
+    if (!lockDirty) return;
+
+    const linked = `${members.map((m) => m.dir).join(', ')} stay linked in node_modules`;
+    if (changed) {
+      say(
+        `WARNING: ${changed.split('\n').join(', ')} differ(s) from HEAD while checkouts are linked (${linked}).`,
+      );
+      say(
+        `${LOCKFILE} now references packages-local and must NOT be committed.`,
+      );
+      say(ADVICE);
+      return;
+    }
+
+    // The staged lockfile is the developer's, unless it was written while linked too.
+    const index = staged();
+    if (index === null) {
+      say(`${LOCKFILE} is not in the index; left as npm wrote it.`);
+      return;
+    }
+    try {
+      // A staged lockfile that lists a checkout is no better than the work tree's: go back to
+      // HEAD. Otherwise the staged one is a deliberate change of the developer's: go back to it.
+      if (LEAK.test(index)) {
+        git('checkout', 'HEAD', '--', LOCKFILE);
+        say(
+          `restored the committed ${LOCKFILE} (the staged one listed a checkout; ${linked})`,
+        );
+      } else {
+        if (!git('diff', '--name-only', '--', LOCKFILE).trim()) return; // the work tree is the index
+        const stagedChange =
+          git('diff', '--cached', '--name-only', '--', LOCKFILE).trim() !== '';
+        git('checkout', '--', LOCKFILE);
+        say(
+          `restored the ${stagedChange ? 'staged' : 'committed'} ${LOCKFILE} (${linked})`,
+        );
+      }
+      say(
+        'Changes to dependencies made while localized are not kept: they need `linked delocalize` first.',
+      );
+    } catch (e) {
+      say(
+        `could not restore ${LOCKFILE}: ${String((e && e.stderr) || e).trim()}`,
+      );
+    }
+  }
+
+  // A clone set up by hand (a bootstrap that copied packages-local/ in, or ran `npm install` only)
+  // never got the git hooks: no pre-commit refuses a leaked lockfile, and no npm install follows a
+  // pull. The lines to print when this is a work tree, `core.hooksPath` is unset (then the hooks
+  // are added by hand, see git-hooks.ts) and the hooks directory has no pre-commit that runs ours;
+  // none otherwise.
+  function hooksNotice(members) {
+    try {
+      if (git('rev-parse', '--is-inside-work-tree').trim() !== 'true')
+        return [];
+    } catch {
+      return [];
+    }
+    try {
+      if (git('config', 'core.hooksPath').trim()) return [];
+    } catch {
+      /* unset */
+    }
+    let file, prefix;
+    try {
+      file = path.resolve(
+        root,
+        git('rev-parse', '--git-path', 'hooks').trim(),
+        'pre-commit',
+      );
+      prefix = git('rev-parse', '--show-prefix').trim();
+    } catch {
+      return [];
+    }
+    let text = null;
+    try {
+      text = fs.readFileSync(file, 'utf8');
+    } catch {
+      /* no pre-commit */
+    }
+    if (text === null) {
+      // --adopt needs a git checkout: name one that is.
+      const checkout = members.find((m) =>
+        fs.existsSync(path.join(root, m.dir, '.git')),
+      );
+      const name = checkout ? checkout.name : "<any checkout's name>";
+      return [
+        `git hooks are not installed in this clone: run \`npx linked localize ${name} --adopt --build ''\` once`,
+      ];
+    }
+    if (runsOurHook(text)) return [];
+    // localize leaves a hook it did not write alone, so --adopt would not help: add ours by hand.
+    return [
+      `${path.relative(root, file)} is not ours, so nothing refuses a commit of a lockfile that ` +
+        'lists a checkout. Add this line to it if it is an `sh` script (another kind, such as the ' +
+        'Python hook the pre-commit framework writes, needs it run from an `sh` hook of its own; ' +
+        'it does nothing where the cli is not installed):',
+      `  ${hookLine('pre-commit', prefix)}`,
+    ];
+  }
+
+  // The drift report and the missing-hooks notice, after the hidden lockfile npm just wrote; only
+  // when its content changed since the last report, so the second of `postinstall` and
+  // `dependencies`, and an install that changed nothing, stay quiet. npm rewrites the file on every
+  // install, so its mtime says nothing: the stamp is a hash of the content. Report only.
+  function report(members) {
+    const nodeModules = path.join(root, 'node_modules');
+    let content;
+    try {
+      content = fs.readFileSync(path.join(nodeModules, '.package-lock.json'));
+    } catch {
+      return; // nothing installed
+    }
+    const stamp = `${createHash('sha1').update(content).digest('hex')}\n`;
+    const stampFile = path.join(
+      nodeModules,
+      '.cache',
+      'linked-localize',
+      'drift-stamp',
+    );
+    try {
+      if (fs.readFileSync(stampFile, 'utf8') === stamp) return;
+    } catch {
+      /* no report yet */
+    }
+    const {driftProblems, describeDrift} = require('./drift.cjs');
+    for (const d of driftProblems(root))
+      write(`[localize] drift: ${describeDrift(d)}\n`);
+    for (const line of hooksNotice(members)) say(line);
+    try {
+      fs.mkdirSync(path.dirname(stampFile), {recursive: true});
+      fs.writeFileSync(stampFile, stamp);
+    } catch {
+      /* reported again next time */
+    }
+  }
+
+  try {
+    // Rare, and the checkouts there are invisible to npm until moved back: said on every install.
+    if (fs.existsSync(path.join(root, SETUP_ASIDE)))
+      say(
+        `checkouts are set aside in ${SETUP_ASIDE}/ (an interrupted set-up): \`npx linked localize --list\` moves them back`,
+      );
+    const members = localMembers(root);
+    if (!members.length) return; // nothing localized: npm owns the lockfile as usual
+    restore(members);
+    report(members);
+  } catch (e) {
+    say(`skipped: ${e && e.message ? e.message : e}`);
+  } finally {
+    if (typeof tty === 'number') {
+      try {
+        fs.closeSync(tty);
+      } catch {
+        /* closed already */
+      }
+    }
+  }
+}
+
+run();

package/hooks/manifests.cjs

@@ -0,0 +1,216 @@
+// What the hooks and the drift check need to know about the app's own manifests: its workspace
+// globs, the git pathspecs of every dependency manifest they cover, its checkouts, and what a
+// leaked checkout looks like in a committed manifest.
+// Plain, unbuilt CommonJS with Node built-ins only, like the other files in hooks/.
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+const LOCAL_DIR = 'packages-local';
+
+// A committed package.json or package-lock.json that lists a checkout: "packages-local/<dir>".
+// The glob "packages-local/*" itself is the committed setup and is allowed.
+const LEAK = /"packages-local\/(?!\*")/;
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The app's `workspaces` globs as written (the array, or yarn's `{packages: [...]}`, which npm
+ * reads too), or null when it has none or its package.json cannot be read.
+ */
+function workspaceGlobs(appRoot) {
+  const pkg = readJson(path.join(appRoot, 'package.json'));
+  const ws = pkg && pkg.workspaces;
+  const globs = Array.isArray(ws)
+    ? ws
+    : ws && Array.isArray(ws.packages)
+      ? ws.packages
+      : null;
+  return globs ? globs.filter((g) => typeof g === 'string' && g !== '') : null;
+}
+
+// A glob without its leading `./` and trailing slashes; null for a negation or a checkout glob.
+function trackedGlob(glob) {
+  if (glob.startsWith('!')) return null;
+  const g = glob.replace(/^\.\//, '').replace(/\/+$/, '');
+  if (g === '' || g === LOCAL_DIR || g.startsWith(`${LOCAL_DIR}/`)) return null;
+  return g;
+}
+
+/**
+ * The workspace globs that hold tracked members: every glob but the checkouts' own. `fallback` is
+ * what an app without `workspaces` gets.
+ */
+function trackedGlobs(appRoot, fallback = []) {
+  const globs = workspaceGlobs(appRoot);
+  const out = [];
+  for (const glob of globs || fallback) {
+    const g = trackedGlob(glob);
+    if (g !== null && !out.includes(g)) out.push(g);
+  }
+  return out;
+}
+
+/**
+ * The git pathspecs, relative to the app directory, of the manifests whose change is a change of
+ * dependencies: `package.json` and `<glob>/package.json` for each workspace glob except
+ * `packages-local/*` (checkouts are not committed).
+ */
+function manifestPathspecs(appRoot) {
+  return [
+    'package.json',
+    ...trackedGlobs(appRoot).map((g) => `${g}/package.json`),
+  ];
+}
+
+/** One glob segment (`*`, `?`, literal text) as a regular expression. */
+function segmentRegExp(segment) {
+  const body = segment
+    .split('')
+    .map((c) =>
+      c === '*'
+        ? '[^/]*'
+        : c === '?'
+          ? '[^/]'
+          : c.replace(/[.+^${}()|[\]\\]/g, '\\$&'),
+    )
+    .join('');
+  return new RegExp(`^${body}$`);
+}
+
+/**
+ * The directories, relative to the app and sorted per glob, that `globs` match and that hold a
+ * package.json. Globs are matched one path segment at a time; `**` matches any depth below it
+ * (node_modules and dot directories excepted).
+ */
+function expandGlobs(appRoot, globs) {
+  const found = [];
+  const walk = (rel, segments) => {
+    if (!segments.length) {
+      if (
+        rel &&
+        fs.existsSync(path.join(appRoot, rel, 'package.json')) &&
+        !found.includes(rel)
+      )
+        found.push(rel);
+      return;
+    }
+    const [segment, ...rest] = segments;
+    if (!/[*?]/.test(segment))
+      return walk(rel ? `${rel}/${segment}` : segment, rest);
+    let entries = [];
+    try {
+      entries = fs
+        .readdirSync(path.join(appRoot, rel), {withFileTypes: true})
+        .filter(
+          (e) =>
+            (e.isDirectory() || e.isSymbolicLink()) &&
+            !e.name.startsWith('.') &&
+            e.name !== 'node_modules',
+        )
+        .map((e) => e.name)
+        .sort();
+    } catch {
+      return;
+    }
+    if (segment === '**') {
+      walk(rel, rest);
+      for (const name of entries) walk(rel ? `${rel}/${name}` : name, segments);
+      return;
+    }
+    const re = segmentRegExp(segment);
+    for (const name of entries)
+      if (re.test(name)) walk(rel ? `${rel}/${name}` : name, rest);
+  };
+  for (const glob of globs) walk('', glob.split('/'));
+  return found;
+}
+
+/**
+ * Do the workspace `globs` match `rel` (a directory relative to the app, `/`-separated) the way
+ * `expandGlobs` would find it -- `*` and `?` within a segment, `**` across any depth, never into
+ * node_modules or a dot directory -- and does no negation (`!glob`) exclude it?
+ */
+function globsMatch(globs, rel) {
+  const target = rel.split('/').filter((s) => s !== '' && s !== '.');
+  if (!target.length) return false;
+  const matches = (segments, names) => {
+    if (!segments.length) return !names.length;
+    const [segment, ...rest] = segments;
+    if (segment === '**') {
+      if (matches(rest, names)) return true;
+      return (
+        names.length > 0 &&
+        wildcardName(names[0]) &&
+        matches(segments, names.slice(1))
+      );
+    }
+    if (!names.length) return false;
+    if (/[*?]/.test(segment)) {
+      if (!wildcardName(names[0]) || !segmentRegExp(segment).test(names[0]))
+        return false;
+    } else if (segment !== names[0]) return false;
+    return matches(rest, names.slice(1));
+  };
+  const split = (g) =>
+    g
+      .replace(/^\.\//, '')
+      .replace(/\/+$/, '')
+      .split('/')
+      .filter((s) => s !== '');
+  let included = false;
+  for (const glob of globs) {
+    if (glob.startsWith('!')) {
+      if (matches(split(glob.slice(1)), target)) return false;
+    } else if (!included && matches(split(glob), target)) included = true;
+  }
+  return included;
+}
+
+// What a wildcard segment may stand for: not node_modules, not a dot directory.
+function wildcardName(name) {
+  return !name.startsWith('.') && name !== 'node_modules';
+}
+
+/**
+ * The checkouts npm links: every directory in `packages-local/` with a named package.json, as
+ * `{name, version, dir}` with `dir` app-relative, sorted by name.
+ */
+function localMembers(appRoot) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(path.join(appRoot, LOCAL_DIR));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of entries) {
+    if (entry.startsWith('.')) continue;
+    const pkg = readJson(path.join(appRoot, LOCAL_DIR, entry, 'package.json'));
+    if (!pkg || typeof pkg.name !== 'string' || !pkg.name) continue;
+    out.push({
+      name: pkg.name,
+      version: typeof pkg.version === 'string' ? pkg.version : '',
+      dir: `${LOCAL_DIR}/${entry}`,
+    });
+  }
+  return out.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+
+module.exports = {
+  LOCAL_DIR,
+  LEAK,
+  readJson,
+  workspaceGlobs,
+  trackedGlobs,
+  manifestPathspecs,
+  expandGlobs,
+  globsMatch,
+  localMembers,
+};

package/hooks/platform.cjs

@@ -0,0 +1,25 @@
+// What the hooks do differently on Windows. Plain, unbuilt CommonJS with Node built-ins only, like
+// the other files in hooks/; src/utils/spawn.ts is the cli's fuller version of npmCommand.
+'use strict';
+
+/**
+ * How to run `npm <args>` on `platform`: on Windows npm is `npm.cmd`, a batch file Node refuses to
+ * spawn without a shell (EINVAL since Node 18.20.2 / 20.12.2), so it goes through cmd.exe. The
+ * arguments are fixed flags, with nothing cmd.exe would read specially.
+ */
+function npmCommand(args, platform = process.platform) {
+  if (platform !== 'win32')
+    return {command: 'npm', args: [...args], shell: false};
+  if (args.some((a) => !/^[\w@./=:-]+$/.test(a)))
+    throw new Error(
+      `npmCommand: unsafe argument for cmd.exe: ${args.join(' ')}`,
+    );
+  return {command: ['npm.cmd', ...args].join(' '), args: [], shell: true};
+}
+
+/** The terminal to also write to, past npm's piping: none on Windows, which has no `/dev/tty`. */
+function terminalDevice(platform = process.platform) {
+  return platform === 'win32' ? null : '/dev/tty';
+}
+
+module.exports = {npmCommand, terminalDevice};

package/lib/esm/app-release/build-backend.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-backend.d.ts","sourceRoot":"","sources":["../../../src/app-release/build-backend.ts"],"names":[],"mappings":"AA+BA,eAAO,MAAM,qBAAqB,GAChC,SAAS,MAAM,EACf,SAAQ,CAAC,CAAC,EAAE,MAAM,KAAK,OAAuB,KAC7C,MAAM,CAAC,MAAM,EAAE,MAAM,CAWvB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,8BAA8B,GACzC,SAAS,MAAM,EACf,WAAU,CACR,KAAK,EAAE,MAAM,EAAE,EACf,GAAG,EAAE,MAAM,KACR,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,EAAE,CAG5B,KACA,OAAO,CAAC,MAAM,EAAE,CAGlB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,MAAM,KAAG,MAAM,EAK3D,CAAC;AAEF,yEAAyE;AACzE,MAAM,WAAW,oBAAoB;IACnC,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AA4CD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC7B,SAAS,MAAM,EACf,WAAU,CACR,KAAK,EAAE,MAAM,EAAE,EACf,GAAG,EAAE,MAAM,KACR,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,EAAE,CAG5C,KACA,OAAO,CAAC,WAAW,EAAE,CA0BvB,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,yBAAyB,GACpC,SAAS,MAAM,EACf,cAAc,WAAW,EAAE,KAC1B,OAAO,CAAC;IAAC,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAC,CAgFhE,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB,GACpC,SAAS,MAAM,EACf,eAAe,WAAW,EAAE,KAC3B,OAAO,CAAC,IAAI,CA4Bd,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,gCAAgC,GAC3C,SAAS,MAAM,EACf,oBAAoB,MAAM,EAAE,KAC3B,MAAM,GAAG,IAgBX,CAAC;AAqBF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,oBAAoB,GAC/B,UAAS;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAM,EAChC,eAAc;IAAC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CAAM,KACjE,OAAO,CAAC,IAAI,CAqFd,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GACjC,SAAS,MAAM,EACf,cAAc,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,KAC/C,OAAO,CAAC,MAAM,CAYhB,CAAC"}
+{"version":3,"file":"build-backend.d.ts","sourceRoot":"","sources":["../../../src/app-release/build-backend.ts"],"names":[],"mappings":"AAgCA,eAAO,MAAM,qBAAqB,GAChC,SAAS,MAAM,EACf,SAAQ,CAAC,CAAC,EAAE,MAAM,KAAK,OAAuB,KAC7C,MAAM,CAAC,MAAM,EAAE,MAAM,CAWvB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,8BAA8B,GACzC,SAAS,MAAM,EACf,WAAU,CACR,KAAK,EAAE,MAAM,EAAE,EACf,GAAG,EAAE,MAAM,KACR,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,EAAE,CAG5B,KACA,OAAO,CAAC,MAAM,EAAE,CAGlB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,MAAM,KAAG,MAAM,EAK3D,CAAC;AAEF,yEAAyE;AACzE,MAAM,WAAW,oBAAoB;IACnC,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AA4CD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC7B,SAAS,MAAM,EACf,WAAU,CACR,KAAK,EAAE,MAAM,EAAE,EACf,GAAG,EAAE,MAAM,KACR,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,EAAE,CAG5C,KACA,OAAO,CAAC,WAAW,EAAE,CA0BvB,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,yBAAyB,GACpC,SAAS,MAAM,EACf,cAAc,WAAW,EAAE,KAC1B,OAAO,CAAC;IAAC,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAC,CAgFhE,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB,GACpC,SAAS,MAAM,EACf,eAAe,WAAW,EAAE,KAC3B,OAAO,CAAC,IAAI,CA4Bd,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,gCAAgC,GAC3C,SAAS,MAAM,EACf,oBAAoB,MAAM,EAAE,KAC3B,MAAM,GAAG,IAgBX,CAAC;AAqBF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,oBAAoB,GAC/B,UAAS;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAM,EAChC,eAAc;IAAC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CAAM,KACjE,OAAO,CAAC,IAAI,CAqFd,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GACjC,SAAS,MAAM,EACf,cAAc,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,KAC/C,OAAO,CAAC,MAAM,CAYhB,CAAC"}

package/lib/esm/app-release/build-backend.js

@@ -21,6 +21,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 import { builtinModules } from 'module';
 import fs from 'fs-extra';
 import path from 'path';
+import { fileURLToPath } from 'url';
 /**
  * The backend entry points a compiled app is started from.
  *
@@ -241,7 +242,7 @@ export const findInlinedPackageImports = (appRoot, packageRoots) => __awaiter(vo
             if (!isPath)
                 continue;
             const target = specifier.startsWith('file://')
-                ? specifier.slice('file://'.length)
+                ? fileURLToPath(specifier)
                 : path.resolve(path.dirname(file), specifier);
             let found;
             if (isInside(target, libDir)) {