srcpack 0.2.0 → 0.3.0

package/dist/cli.js

@@ -5547,6 +5547,334 @@ var require_out4 = __commonJS((exports, module) => {
   module.exports = FastGlob;
 });
 
+// node_modules/ignore/index.js
+var require_ignore = __commonJS((exports, module) => {
+  function makeArray(subject) {
+    return Array.isArray(subject) ? subject : [subject];
+  }
+  var UNDEFINED = undefined;
+  var EMPTY = "";
+  var SPACE = " ";
+  var ESCAPE = "\\";
+  var REGEX_TEST_BLANK_LINE = /^\s+$/;
+  var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+  var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+  var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+  var REGEX_SPLITALL_CRLF = /\r?\n/g;
+  var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+  var REGEX_TEST_TRAILING_SLASH = /\/$/;
+  var SLASH = "/";
+  var TMP_KEY_IGNORE = "node-ignore";
+  if (typeof Symbol !== "undefined") {
+    TMP_KEY_IGNORE = Symbol.for("node-ignore");
+  }
+  var KEY_IGNORE = TMP_KEY_IGNORE;
+  var define2 = (object, key, value) => {
+    Object.defineProperty(object, key, { value });
+    return value;
+  };
+  var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+  var RETURN_FALSE = () => false;
+  var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
+  var negateRange = (range) => range.startsWith("!") || range.startsWith("\\^") ? `^${range.slice(range[0] === "!" ? 1 : 2)}` : range;
+  var cleanRangeBackSlash = (slashes) => {
+    const { length } = slashes;
+    return slashes.slice(0, length - length % 2);
+  };
+  var REPLACERS = [
+    [
+      /^\uFEFF/,
+      () => EMPTY
+    ],
+    [
+      /((?:\\\\)*?)(\\?\s+)$/,
+      (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+    ],
+    [
+      /(\\+?)\s/g,
+      (_, m1) => {
+        const { length } = m1;
+        return m1.slice(0, length - length % 2) + SPACE;
+      }
+    ],
+    [
+      /[\\$.|*+(){^]/g,
+      (match) => `\\${match}`
+    ],
+    [
+      /(?!\\)\?/g,
+      () => "[^/]"
+    ],
+    [
+      /^\//,
+      () => "^"
+    ],
+    [
+      /\//g,
+      () => "\\/"
+    ],
+    [
+      /^\^*(?:\\\*\\\*\\\/)+/,
+      () => "^(?:.*\\/)?"
+    ],
+    [
+      /^(?=[^^])/,
+      function startingReplacer() {
+        return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+      }
+    ],
+    [
+      /\\\/\\\*\\\*(?=\\\/|$)/g,
+      (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+    ],
+    [
+      /(^|[^\\]+)(\\\*)+(?=.+)/g,
+      (_, p1, p2) => {
+        const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+        return p1 + unescaped;
+      }
+    ],
+    [
+      /\\\\\\(?=[$.|*+(){^])/g,
+      () => ESCAPE
+    ],
+    [
+      /\\\\/g,
+      () => ESCAPE
+    ],
+    [
+      /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+      (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${negateRange(sanitizeRange(range))}${endEscape}]` : "[]" : "[]"
+    ],
+    [
+      /(?:[^*])$/,
+      (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+    ]
+  ];
+  var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+  var MODE_IGNORE = "regex";
+  var MODE_CHECK_IGNORE = "checkRegex";
+  var UNDERSCORE = "_";
+  var TRAILING_WILD_CARD_REPLACERS = {
+    [MODE_IGNORE](_, p1) {
+      const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    },
+    [MODE_CHECK_IGNORE](_, p1) {
+      const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    }
+  };
+  var makeRegexPrefix = (pattern) => REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern);
+  var isString = (subject) => typeof subject === "string";
+  var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+  var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+
+  class IgnoreRule {
+    constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+      this.pattern = pattern;
+      this.mark = mark;
+      this.negative = negative;
+      define2(this, "body", body);
+      define2(this, "ignoreCase", ignoreCase);
+      define2(this, "regexPrefix", prefix);
+    }
+    get regex() {
+      const key = UNDERSCORE + MODE_IGNORE;
+      if (this[key]) {
+        return this[key];
+      }
+      return this._make(MODE_IGNORE, key);
+    }
+    get checkRegex() {
+      const key = UNDERSCORE + MODE_CHECK_IGNORE;
+      if (this[key]) {
+        return this[key];
+      }
+      return this._make(MODE_CHECK_IGNORE, key);
+    }
+    _make(mode, key) {
+      const str = this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, TRAILING_WILD_CARD_REPLACERS[mode]);
+      const regex2 = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+      return define2(this, key, regex2);
+    }
+  }
+  var createRule = ({
+    pattern,
+    mark
+  }, ignoreCase) => {
+    let negative = false;
+    let body = pattern;
+    if (body.indexOf("!") === 0) {
+      negative = true;
+      body = body.substr(1);
+    }
+    body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+    const regexPrefix = makeRegexPrefix(body);
+    return new IgnoreRule(pattern, mark, body, ignoreCase, negative, regexPrefix);
+  };
+
+  class RuleManager {
+    constructor(ignoreCase) {
+      this._ignoreCase = ignoreCase;
+      this._rules = [];
+    }
+    _add(pattern) {
+      if (pattern && pattern[KEY_IGNORE]) {
+        this._rules = this._rules.concat(pattern._rules._rules);
+        this._added = true;
+        return;
+      }
+      if (isString(pattern)) {
+        pattern = {
+          pattern
+        };
+      }
+      if (checkPattern(pattern.pattern)) {
+        const rule = createRule(pattern, this._ignoreCase);
+        this._added = true;
+        this._rules.push(rule);
+      }
+    }
+    add(pattern) {
+      this._added = false;
+      makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
+      return this._added;
+    }
+    test(path, checkUnignored, mode) {
+      let ignored = false;
+      let unignored = false;
+      let matchedRule;
+      this._rules.forEach((rule) => {
+        const { negative } = rule;
+        if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+          return;
+        }
+        const matched = rule[mode].test(path);
+        if (!matched) {
+          return;
+        }
+        ignored = !negative;
+        unignored = negative;
+        matchedRule = negative ? UNDEFINED : rule;
+      });
+      const ret = {
+        ignored,
+        unignored
+      };
+      if (matchedRule) {
+        ret.rule = matchedRule;
+      }
+      return ret;
+    }
+  }
+  var throwError = (message, Ctor) => {
+    throw new Ctor(message);
+  };
+  var checkPath = (path, originalPath, doThrow) => {
+    if (!isString(path)) {
+      return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+    }
+    if (!path) {
+      return doThrow(`path must not be empty`, TypeError);
+    }
+    if (checkPath.isNotRelative(path)) {
+      const r = "`path.relative()`d";
+      return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
+    }
+    return true;
+  };
+  var isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+  checkPath.isNotRelative = isNotRelative;
+  checkPath.convert = (p) => p;
+
+  class Ignore {
+    constructor({
+      ignorecase = true,
+      ignoreCase = ignorecase,
+      allowRelativePaths = false
+    } = {}) {
+      define2(this, KEY_IGNORE, true);
+      this._rules = new RuleManager(ignoreCase);
+      this._strictPathCheck = !allowRelativePaths;
+      this._initCache();
+    }
+    _initCache() {
+      this._ignoreCache = Object.create(null);
+      this._testCache = Object.create(null);
+    }
+    add(pattern) {
+      if (this._rules.add(pattern)) {
+        this._initCache();
+      }
+      return this;
+    }
+    addPattern(pattern) {
+      return this.add(pattern);
+    }
+    _test(originalPath, cache, checkUnignored, slices) {
+      const path = originalPath && checkPath.convert(originalPath);
+      checkPath(path, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
+      return this._t(path, cache, checkUnignored, slices);
+    }
+    checkIgnore(path) {
+      if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
+        return this.test(path);
+      }
+      const slices = path.split(SLASH).filter(Boolean);
+      slices.pop();
+      if (slices.length) {
+        const parent = this._t(slices.join(SLASH) + SLASH, this._testCache, true, slices);
+        if (parent.ignored) {
+          return parent;
+        }
+      }
+      return this._rules.test(path, false, MODE_CHECK_IGNORE);
+    }
+    _t(path, cache, checkUnignored, slices) {
+      if (path in cache) {
+        return cache[path];
+      }
+      if (!slices) {
+        slices = path.split(SLASH).filter(Boolean);
+      }
+      slices.pop();
+      if (!slices.length) {
+        return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
+      }
+      const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
+      return cache[path] = parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
+    }
+    ignores(path) {
+      return this._test(path, this._ignoreCache, false).ignored;
+    }
+    createFilter() {
+      return (path) => !this.ignores(path);
+    }
+    filter(paths) {
+      return makeArray(paths).filter(this.createFilter());
+    }
+    test(path) {
+      return this._test(path, this._testCache, true);
+    }
+  }
+  var factory = (options) => new Ignore(options);
+  var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+  var setupWindows = () => {
+    const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+    checkPath.convert = makePosix;
+    const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+    checkPath.isNotRelative = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+  };
+  if (typeof process !== "undefined" && process.platform === "win32") {
+    setupWindows();
+  }
+  module.exports = factory;
+  factory.default = factory;
+  module.exports.isPathValid = isPathValid;
+  define2(module.exports, Symbol.for("setupWindows"), setupWindows);
+});
+
 // node_modules/picomatch/lib/constants.js
 var require_constants4 = __commonJS((exports, module) => {
   var WIN_SLASH = "\\\\/";
@@ -7243,334 +7571,6 @@ var require_picomatch3 = __commonJS((exports, module) => {
   module.exports = picomatch;
 });
 
-// node_modules/ignore/index.js
-var require_ignore = __commonJS((exports, module) => {
-  function makeArray(subject) {
-    return Array.isArray(subject) ? subject : [subject];
-  }
-  var UNDEFINED = undefined;
-  var EMPTY = "";
-  var SPACE = " ";
-  var ESCAPE = "\\";
-  var REGEX_TEST_BLANK_LINE = /^\s+$/;
-  var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
-  var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
-  var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
-  var REGEX_SPLITALL_CRLF = /\r?\n/g;
-  var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
-  var REGEX_TEST_TRAILING_SLASH = /\/$/;
-  var SLASH = "/";
-  var TMP_KEY_IGNORE = "node-ignore";
-  if (typeof Symbol !== "undefined") {
-    TMP_KEY_IGNORE = Symbol.for("node-ignore");
-  }
-  var KEY_IGNORE = TMP_KEY_IGNORE;
-  var define2 = (object, key, value) => {
-    Object.defineProperty(object, key, { value });
-    return value;
-  };
-  var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
-  var RETURN_FALSE = () => false;
-  var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
-  var negateRange = (range) => range.startsWith("!") || range.startsWith("\\^") ? `^${range.slice(range[0] === "!" ? 1 : 2)}` : range;
-  var cleanRangeBackSlash = (slashes) => {
-    const { length } = slashes;
-    return slashes.slice(0, length - length % 2);
-  };
-  var REPLACERS = [
-    [
-      /^\uFEFF/,
-      () => EMPTY
-    ],
-    [
-      /((?:\\\\)*?)(\\?\s+)$/,
-      (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
-    ],
-    [
-      /(\\+?)\s/g,
-      (_, m1) => {
-        const { length } = m1;
-        return m1.slice(0, length - length % 2) + SPACE;
-      }
-    ],
-    [
-      /[\\$.|*+(){^]/g,
-      (match) => `\\${match}`
-    ],
-    [
-      /(?!\\)\?/g,
-      () => "[^/]"
-    ],
-    [
-      /^\//,
-      () => "^"
-    ],
-    [
-      /\//g,
-      () => "\\/"
-    ],
-    [
-      /^\^*(?:\\\*\\\*\\\/)+/,
-      () => "^(?:.*\\/)?"
-    ],
-    [
-      /^(?=[^^])/,
-      function startingReplacer() {
-        return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
-      }
-    ],
-    [
-      /\\\/\\\*\\\*(?=\\\/|$)/g,
-      (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
-    ],
-    [
-      /(^|[^\\]+)(\\\*)+(?=.+)/g,
-      (_, p1, p2) => {
-        const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
-        return p1 + unescaped;
-      }
-    ],
-    [
-      /\\\\\\(?=[$.|*+(){^])/g,
-      () => ESCAPE
-    ],
-    [
-      /\\\\/g,
-      () => ESCAPE
-    ],
-    [
-      /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
-      (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${negateRange(sanitizeRange(range))}${endEscape}]` : "[]" : "[]"
-    ],
-    [
-      /(?:[^*])$/,
-      (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
-    ]
-  ];
-  var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
-  var MODE_IGNORE = "regex";
-  var MODE_CHECK_IGNORE = "checkRegex";
-  var UNDERSCORE = "_";
-  var TRAILING_WILD_CARD_REPLACERS = {
-    [MODE_IGNORE](_, p1) {
-      const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
-      return `${prefix}(?=$|\\/$)`;
-    },
-    [MODE_CHECK_IGNORE](_, p1) {
-      const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
-      return `${prefix}(?=$|\\/$)`;
-    }
-  };
-  var makeRegexPrefix = (pattern) => REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern);
-  var isString = (subject) => typeof subject === "string";
-  var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
-  var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
-
-  class IgnoreRule {
-    constructor(pattern, mark, body, ignoreCase, negative, prefix) {
-      this.pattern = pattern;
-      this.mark = mark;
-      this.negative = negative;
-      define2(this, "body", body);
-      define2(this, "ignoreCase", ignoreCase);
-      define2(this, "regexPrefix", prefix);
-    }
-    get regex() {
-      const key = UNDERSCORE + MODE_IGNORE;
-      if (this[key]) {
-        return this[key];
-      }
-      return this._make(MODE_IGNORE, key);
-    }
-    get checkRegex() {
-      const key = UNDERSCORE + MODE_CHECK_IGNORE;
-      if (this[key]) {
-        return this[key];
-      }
-      return this._make(MODE_CHECK_IGNORE, key);
-    }
-    _make(mode, key) {
-      const str = this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, TRAILING_WILD_CARD_REPLACERS[mode]);
-      const regex2 = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
-      return define2(this, key, regex2);
-    }
-  }
-  var createRule = ({
-    pattern,
-    mark
-  }, ignoreCase) => {
-    let negative = false;
-    let body = pattern;
-    if (body.indexOf("!") === 0) {
-      negative = true;
-      body = body.substr(1);
-    }
-    body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
-    const regexPrefix = makeRegexPrefix(body);
-    return new IgnoreRule(pattern, mark, body, ignoreCase, negative, regexPrefix);
-  };
-
-  class RuleManager {
-    constructor(ignoreCase) {
-      this._ignoreCase = ignoreCase;
-      this._rules = [];
-    }
-    _add(pattern) {
-      if (pattern && pattern[KEY_IGNORE]) {
-        this._rules = this._rules.concat(pattern._rules._rules);
-        this._added = true;
-        return;
-      }
-      if (isString(pattern)) {
-        pattern = {
-          pattern
-        };
-      }
-      if (checkPattern(pattern.pattern)) {
-        const rule = createRule(pattern, this._ignoreCase);
-        this._added = true;
-        this._rules.push(rule);
-      }
-    }
-    add(pattern) {
-      this._added = false;
-      makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
-      return this._added;
-    }
-    test(path, checkUnignored, mode) {
-      let ignored = false;
-      let unignored = false;
-      let matchedRule;
-      this._rules.forEach((rule) => {
-        const { negative } = rule;
-        if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
-          return;
-        }
-        const matched = rule[mode].test(path);
-        if (!matched) {
-          return;
-        }
-        ignored = !negative;
-        unignored = negative;
-        matchedRule = negative ? UNDEFINED : rule;
-      });
-      const ret = {
-        ignored,
-        unignored
-      };
-      if (matchedRule) {
-        ret.rule = matchedRule;
-      }
-      return ret;
-    }
-  }
-  var throwError = (message, Ctor) => {
-    throw new Ctor(message);
-  };
-  var checkPath = (path, originalPath, doThrow) => {
-    if (!isString(path)) {
-      return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
-    }
-    if (!path) {
-      return doThrow(`path must not be empty`, TypeError);
-    }
-    if (checkPath.isNotRelative(path)) {
-      const r = "`path.relative()`d";
-      return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
-    }
-    return true;
-  };
-  var isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
-  checkPath.isNotRelative = isNotRelative;
-  checkPath.convert = (p) => p;
-
-  class Ignore {
-    constructor({
-      ignorecase = true,
-      ignoreCase = ignorecase,
-      allowRelativePaths = false
-    } = {}) {
-      define2(this, KEY_IGNORE, true);
-      this._rules = new RuleManager(ignoreCase);
-      this._strictPathCheck = !allowRelativePaths;
-      this._initCache();
-    }
-    _initCache() {
-      this._ignoreCache = Object.create(null);
-      this._testCache = Object.create(null);
-    }
-    add(pattern) {
-      if (this._rules.add(pattern)) {
-        this._initCache();
-      }
-      return this;
-    }
-    addPattern(pattern) {
-      return this.add(pattern);
-    }
-    _test(originalPath, cache, checkUnignored, slices) {
-      const path = originalPath && checkPath.convert(originalPath);
-      checkPath(path, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
-      return this._t(path, cache, checkUnignored, slices);
-    }
-    checkIgnore(path) {
-      if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
-        return this.test(path);
-      }
-      const slices = path.split(SLASH).filter(Boolean);
-      slices.pop();
-      if (slices.length) {
-        const parent = this._t(slices.join(SLASH) + SLASH, this._testCache, true, slices);
-        if (parent.ignored) {
-          return parent;
-        }
-      }
-      return this._rules.test(path, false, MODE_CHECK_IGNORE);
-    }
-    _t(path, cache, checkUnignored, slices) {
-      if (path in cache) {
-        return cache[path];
-      }
-      if (!slices) {
-        slices = path.split(SLASH).filter(Boolean);
-      }
-      slices.pop();
-      if (!slices.length) {
-        return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
-      }
-      const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
-      return cache[path] = parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
-    }
-    ignores(path) {
-      return this._test(path, this._ignoreCache, false).ignored;
-    }
-    createFilter() {
-      return (path) => !this.ignores(path);
-    }
-    filter(paths) {
-      return makeArray(paths).filter(this.createFilter());
-    }
-    test(path) {
-      return this._test(path, this._testCache, true);
-    }
-  }
-  var factory = (options) => new Ignore(options);
-  var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
-  var setupWindows = () => {
-    const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
-    checkPath.convert = makePosix;
-    const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-    checkPath.isNotRelative = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
-  };
-  if (typeof process !== "undefined" && process.platform === "win32") {
-    setupWindows();
-  }
-  module.exports = factory;
-  factory.default = factory;
-  module.exports.isPathValid = isPathValid;
-  define2(module.exports, Symbol.for("setupWindows"), setupWindows);
-});
-
 // node_modules/js-yaml/lib/common.js
 var require_common3 = __commonJS((exports, module) => {
   function isNothing(subject) {
@@ -36604,8 +36604,24 @@ var require_src9 = __commonJS((exports, module) => {
 });
 
 // src/cli.ts
-import { mkdir as mkdir3, readdir, readFile as readFile5, rm, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname3, isAbsolute as isAbsolute2, join as join6, relative, resolve as resolve3, sep as sep2 } from "node:path";
+import {
+  mkdir as mkdir3,
+  readdir,
+  readFile as readFile5,
+  realpath,
+  rename as rename2,
+  rm,
+  writeFile as writeFile4
+} from "node:fs/promises";
+import {
+  basename as basename3,
+  dirname as dirname4,
+  isAbsolute as isAbsolute2,
+  join as join6,
+  relative,
+  resolve as resolve3,
+  sep as sep2
+} from "node:path";
 
 // node_modules/ora/index.js
 import process8 from "node:process";
@@ -40012,10 +40028,10 @@ function ora(options) {
 
 // src/bundle.ts
 var import_fast_glob = __toESM(require_out4(), 1);
-var import_picomatch = __toESM(require_picomatch3(), 1);
 var import_ignore = __toESM(require_ignore(), 1);
+var import_picomatch = __toESM(require_picomatch3(), 1);
 import { lstat, open, readFile } from "node:fs/promises";
-import { isAbsolute, join as join2, resolve as resolve2, sep } from "node:path";
+import { dirname, isAbsolute, join as join2, resolve as resolve2, sep } from "node:path";
 
 // src/config.ts
 var import_cosmiconfig = __toESM(require_dist(), 1);
@@ -54309,29 +54325,57 @@ var PatternsSchema = exports_external.union([
   exports_external.string().min(1),
   exports_external.array(exports_external.string().min(1)).min(1)
 ]);
+var IdentifierSchema = exports_external.string().trim().min(1);
+var BundleNameSchema = exports_external.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "Bundle name must start with a letter or digit and contain only letters, digits, dot, underscore or hyphen");
+var LinearSourceSchema = exports_external.union([
+  IdentifierSchema,
+  exports_external.strictObject({
+    team: IdentifierSchema,
+    project: IdentifierSchema.optional(),
+    includeClosed: exports_external.boolean().default(false)
+  })
+]);
 var BundleConfigSchema = exports_external.union([
   exports_external.string().min(1),
   exports_external.array(exports_external.string().min(1)).min(1),
-  exports_external.object({
-    include: PatternsSchema,
-    outfile: exports_external.string().optional(),
+  exports_external.strictObject({
+    include: PatternsSchema.optional(),
+    linear: LinearSourceSchema.optional(),
+    outfile: exports_external.string().min(1).optional(),
     index: exports_external.boolean().default(true),
     prompt: exports_external.string().optional()
+  }).refine((bundle) => bundle.include || bundle.linear, {
+    message: 'Bundle needs a source: "include" patterns, "linear", or both'
   })
 ]);
-var UploadConfigSchema = exports_external.object({
+var UploadConfigSchema = exports_external.strictObject({
   provider: exports_external.literal("gdrive"),
-  folderId: exports_external.string().optional(),
-  clientId: exports_external.string().min(1),
-  clientSecret: exports_external.string().min(1),
+  folderId: IdentifierSchema.optional(),
+  clientId: IdentifierSchema,
+  clientSecret: IdentifierSchema,
   exclude: exports_external.array(exports_external.string()).optional()
 });
-var ConfigSchema = exports_external.object({
+var ConfigSchema = exports_external.strictObject({
   root: exports_external.string().default(""),
   outDir: exports_external.string().default(".srcpack"),
   emptyOutDir: exports_external.boolean().optional(),
   upload: exports_external.union([UploadConfigSchema, exports_external.array(UploadConfigSchema).min(1)]).optional(),
-  bundles: exports_external.record(exports_external.string(), BundleConfigSchema)
+  bundles: exports_external.record(BundleNameSchema, BundleConfigSchema)
+}).superRefine((config2, ctx) => {
+  const uploads = config2.upload ? Array.isArray(config2.upload) ? config2.upload : [config2.upload] : [];
+  const names = new Set(Object.keys(config2.bundles));
+  uploads.forEach((upload, i) => {
+    const path = Array.isArray(config2.upload) ? ["upload", i, "exclude"] : ["upload", "exclude"];
+    for (const name of upload.exclude ?? []) {
+      if (!names.has(name)) {
+        ctx.addIssue({
+          code: "custom",
+          path,
+          message: `Unknown bundle "${name}"`
+        });
+      }
+    }
+  });
 });
 function defineConfig(config2) {
   return config2;
@@ -54343,13 +54387,22 @@ class ConfigError extends Error {
     this.name = "ConfigError";
   }
 }
+function flatten(issue2, prefix = []) {
+  const path = [...prefix, ...issue2.path];
+  const nested = issue2.code === "invalid_union" ? issue2.errors?.flat() : issue2.code === "invalid_key" ? issue2.issues : undefined;
+  return nested?.length ? nested.flatMap((child) => flatten(child, path)) : [{ ...issue2, path }];
+}
+function describe3(issues) {
+  const leaves = issues.flatMap((issue2) => flatten(issue2));
+  const specific = leaves.filter((leaf) => leaf.code !== "invalid_type");
+  const best = (specific.length ? specific : leaves).reduce((a, b) => b.path.length > a.path.length ? b : a);
+  const path = best.path.join(".");
+  return path ? `${path}: ${best.message}` : best.message;
+}
 function parseConfig(value) {
   const result = ConfigSchema.safeParse(value);
   if (!result.success) {
-    const issue2 = result.error.issues[0];
-    const path = issue2.path.join(".");
-    const message = path ? `${path}: ${issue2.message}` : issue2.message;
-    throw new ConfigError(message);
+    throw new ConfigError(describe3(result.error.issues));
   }
   const config2 = result.data;
   config2.root = config2.root ? resolve(expandPath(config2.root)) : process.cwd();
@@ -54456,8 +54509,217 @@ async function resolveGitSource(pattern, cwd) {
   }
 }
 
+// src/linear.ts
+var API_URL = "https://api.linear.app/graphql";
+var TIMEOUT_MS = 30000;
+var TOKEN_ENV = "LINEAR_API_KEY";
+var PAGE = 50;
+var CLOSED_STATES = ["completed", "canceled", "duplicate"];
+var PRIORITY = ["None", "Urgent", "High", "Medium", "Low"];
+
+class LinearError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LinearError";
+  }
+}
+function requireToken() {
+  const token = process.env[TOKEN_ENV]?.trim();
+  if (!token) {
+    throw new LinearError(`${TOKEN_ENV} is not set. Create a personal API key in Linear ` + "(Settings → Security & access → Personal API keys).");
+  }
+  return token;
+}
+async function graphql(query, variables, token) {
+  let response;
+  try {
+    response = await fetch(API_URL, {
+      method: "POST",
+      headers: { authorization: token, "content-type": "application/json" },
+      body: JSON.stringify({ query, variables }),
+      signal: AbortSignal.timeout(TIMEOUT_MS)
+    });
+  } catch (error52) {
+    if (error52.name === "TimeoutError") {
+      throw new LinearError(`Linear API request timed out after ${TIMEOUT_MS / 1000}s.`);
+    }
+    throw new LinearError(`Cannot reach the Linear API: ${error52.message}`);
+  }
+  if (response.status === 401 || response.status === 403) {
+    throw new LinearError(`${TOKEN_ENV} was rejected by Linear (not authorized).`);
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    throw new LinearError(`Linear API returned ${response.status}.`);
+  }
+  if (body.errors?.length) {
+    throw new LinearError(body.errors.map((e) => e.message).join("; "));
+  }
+  if (!response.ok || !body.data) {
+    throw new LinearError(`Linear API returned ${response.status}.`);
+  }
+  return body.data;
+}
+function normalize(source) {
+  if (typeof source === "string") {
+    return { team: source, includeClosed: false };
+  }
+  return {
+    team: source.team,
+    project: source.project,
+    includeClosed: source.includeClosed ?? false
+  };
+}
+async function resolveScope(team, project, token) {
+  const projects = project ? "projects(filter: { name: { eq: $project } }, first: 2) { nodes { id } }" : "";
+  const query = `
+    query ($team: String!${project ? ", $project: String!" : ""}) {
+      teams(filter: { key: { eq: $team } }, first: 1) {
+        nodes { key ${projects} }
+      }
+    }
+  `;
+  const data = await graphql(query, project ? { team, project } : { team }, token);
+  const found = data.teams.nodes[0];
+  if (!found) {
+    throw new LinearError(`Team "${team}" not found in this Linear workspace. ` + "Use the team key shown in issue identifiers (the ENG in ENG-123).");
+  }
+  if (!project)
+    return {};
+  const matches = found.projects?.nodes ?? [];
+  if (matches.length === 0) {
+    throw new LinearError(`Project "${project}" not found in team "${team}".`);
+  }
+  if (matches.length > 1) {
+    throw new LinearError(`Project "${project}" is ambiguous: team "${team}" has more than one project with that name.`);
+  }
+  return { projectId: matches[0].id };
+}
+async function fetchIssues(filter, token) {
+  const query = `
+    query ($cursor: String, $filter: IssueFilter) {
+      issues(first: ${PAGE}, after: $cursor, filter: $filter, orderBy: createdAt) {
+        nodes {
+          identifier
+          title
+          description
+          priority
+          estimate
+          dueDate
+          url
+          createdAt
+          updatedAt
+          state { name type }
+          # A deliberate cap, not pagination: 50 labels is far past what an
+          # issue carries, and each nested page multiplies query complexity
+          labels(first: 50) { nodes { name parent { name } } }
+          project { name }
+          projectMilestone { name }
+          parent { identifier }
+          assignee { name }
+        }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  `;
+  const issues = [];
+  let cursor = null;
+  do {
+    const data = await graphql(query, { cursor, filter }, token);
+    issues.push(...data.issues.nodes);
+    cursor = data.issues.pageInfo.hasNextPage ? data.issues.pageInfo.endCursor : null;
+  } while (cursor);
+  return issues;
+}
+function stripEmbeds(markdown) {
+  return markdown.replace(/<linear-embed\b[^>]*>.*?<\/linear-embed>/gs, "[embed]").replace(/<linear-embed\b[^>]*\/?>/g, "[embed]").trimEnd();
+}
+function labelNames(issue2) {
+  return issue2.labels.nodes.map((l) => l.parent ? `${l.parent.name}/${l.name}` : l.name);
+}
+function issueNumber(issue2) {
+  const n = Number(issue2.identifier.split("-").pop());
+  return Number.isFinite(n) ? n : Number.MAX_SAFE_INTEGER;
+}
+function renderSummary(scope, issues) {
+  const tally = new Map;
+  for (const issue2 of issues) {
+    tally.set(issue2.state.name, (tally.get(issue2.state.name) ?? 0) + 1);
+  }
+  const counts = [...tally].sort((a, b) => b[1] - a[1]).map(([name, n]) => `${name} ${n}`).join(" · ");
+  const rows = [...issues].sort((a, b) => issueNumber(a) - issueNumber(b)).map((issue2) => {
+    const title = issue2.title.replace(/\|/g, "\\|");
+    const priority = PRIORITY[issue2.priority] ?? String(issue2.priority);
+    return `| ${issue2.identifier} | ${issue2.state.name} | ${priority} | ${title} |`;
+  });
+  return [
+    `# ${scope} — ${issues.length} ${issues.length === 1 ? "issue" : "issues"}`,
+    "",
+    counts,
+    "",
+    "| Issue | State | Priority | Title |",
+    "| --- | --- | --- | --- |",
+    ...rows
+  ].join(`
+`);
+}
+function render(issue2) {
+  const field = (name, value) => `${name.padEnd(10)} ${value?.length ? value : "—"}`;
+  const description = issue2.description?.trim() ? stripEmbeds(issue2.description) : "(no description)";
+  return [
+    `# ${issue2.identifier}  ${issue2.title}`,
+    "",
+    field("State", `${issue2.state.name} (${issue2.state.type})`),
+    field("Priority", PRIORITY[issue2.priority] ?? String(issue2.priority)),
+    field("Estimate", issue2.estimate === null ? null : String(issue2.estimate)),
+    field("Labels", labelNames(issue2).join(", ")),
+    field("Project", issue2.project?.name),
+    field("Milestone", issue2.projectMilestone?.name),
+    field("Parent", issue2.parent?.identifier),
+    field("Assignee", issue2.assignee?.name),
+    field("Due", issue2.dueDate),
+    field("Created", issue2.createdAt.slice(0, 10)),
+    field("Updated", issue2.updatedAt.slice(0, 10)),
+    field("URL", issue2.url),
+    "",
+    description
+  ].join(`
+`);
+}
+async function resolveLinearSource(source) {
+  const { team, project, includeClosed } = normalize(source);
+  const token = requireToken();
+  const { projectId } = await resolveScope(team, project, token);
+  const filter = { team: { key: { eq: team } } };
+  if (projectId)
+    filter.project = { id: { eq: projectId } };
+  if (!includeClosed)
+    filter.state = { type: { nin: CLOSED_STATES } };
+  const issues = await fetchIssues(filter, token);
+  if (issues.length === 0)
+    return [];
+  const scope = project ? `${team} / ${project}` : team;
+  const entries = [
+    { path: "linear/issues.md", content: renderSummary(scope, issues) }
+  ];
+  for (const issue2 of issues) {
+    entries.push({
+      path: `linear/issues/${issue2.identifier}.md`,
+      content: render(issue2)
+    });
+  }
+  return entries;
+}
+
 // src/bundle.ts
 var BINARY_CHECK_SIZE = 8192;
+var GLOB_OPTIONS = {
+  onlyFiles: true,
+  dot: true,
+  followSymbolicLinks: false
+};
 async function isBundleable(filePath) {
   let stats;
   try {
@@ -54493,6 +54755,8 @@ function normalizePatterns(config2) {
     patterns = [config2];
   } else if (Array.isArray(config2)) {
     patterns = config2;
+  } else if (config2.include === undefined) {
+    patterns = [];
   } else {
     patterns = Array.isArray(config2.include) ? config2.include : [config2.include];
   }
@@ -54534,27 +54798,73 @@ function gitignoreToGlobPatterns(lines) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#"))
       continue;
-    if (trimmed.startsWith("/") || trimmed.includes("*") || trimmed.includes("?") || trimmed.includes("[") || trimmed.includes("/") || trimmed.includes("\\")) {
+    const name = trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+    if (name.startsWith("/") || name.includes("*") || name.includes("?") || name.includes("[") || name.includes("/") || name.includes("\\")) {
       continue;
     }
-    const name = trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
     if (name && /^[\w.-]+$/.test(name)) {
       patterns.push(`**/${name}/**`);
     }
   }
   return patterns;
 }
-async function loadGitignore(cwd) {
-  const ig = import_ignore.default();
-  const gitignorePath = join2(cwd, ".gitignore");
-  let globPatterns = [];
+async function readIgnoreFile(path) {
   try {
-    const content = await readFile(gitignorePath, "utf-8");
-    ig.add(content);
-    globPatterns = gitignoreToGlobPatterns(content.split(`
-`));
-  } catch {}
-  return { ignore: ig, globPatterns };
+    return await readFile(path, "utf-8");
+  } catch (error52) {
+    if (error52.code === "ENOENT")
+      return null;
+    throw new ConfigError(`Cannot read "${path}": ${error52.message}. ` + "srcpack stops rather than bundle files it cannot confirm are ignored.");
+  }
+}
+async function loadGitignore(cwd) {
+  const rootContent = await readIgnoreFile(join2(cwd, ".gitignore"));
+  const globPatterns = rootContent ? gitignoreToGlobPatterns(rootContent.split(`
+`)) : [];
+  const layers = [];
+  if (rootContent)
+    layers.push({ dir: "", ig: import_ignore.default().add(rootContent) });
+  const nested = await import_fast_glob.glob(["**/.gitignore"], {
+    cwd,
+    dot: true,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    ignore: globPatterns
+  });
+  for (const file2 of nested) {
+    const content = await readIgnoreFile(join2(cwd, file2));
+    if (content)
+      layers.push({ dir: dirname(file2), ig: import_ignore.default().add(content) });
+  }
+  return { ignores: makeIgnores(layers), globPatterns };
+}
+function makeIgnores(layers) {
+  if (layers.length === 0)
+    return () => false;
+  const ordered = [...layers].sort((a, b) => b.dir.length - a.dir.length);
+  const opinion = (path) => {
+    for (const { dir, ig } of ordered) {
+      if (dir && !path.startsWith(`${dir}/`))
+        continue;
+      const relative = dir ? path.slice(dir.length + 1) : path;
+      if (!relative || relative === "/")
+        continue;
+      const { ignored, unignored } = ig.test(relative);
+      if (ignored)
+        return true;
+      if (unignored)
+        return false;
+    }
+    return;
+  };
+  return (path) => {
+    const segments = path.split("/");
+    for (let i = 1;i < segments.length; i++) {
+      if (opinion(`${segments.slice(0, i).join("/")}/`))
+        return true;
+    }
+    return opinion(path) === true;
+  };
 }
 function isExternalPattern(pattern) {
   if (isAbsolute(pattern))
@@ -54562,8 +54872,15 @@ function isExternalPattern(pattern) {
   const normalized = pattern.startsWith("./") ? pattern.slice(2) : pattern;
   return normalized.startsWith("../");
 }
+function pathKey(path) {
+  return path.normalize("NFC").toLowerCase();
+}
 function isOwnOutput(filePath, outputs) {
-  return outputs.some((out) => filePath === out || filePath.startsWith(out + sep));
+  const key = pathKey(filePath);
+  return outputs.some((out) => {
+    const outKey = pathKey(out);
+    return key === outKey || key.startsWith(outKey + sep);
+  });
 }
 async function resolvePatterns(config2, cwd, outputs = []) {
   const { include, exclude, force } = normalizePatterns(config2);
@@ -54591,24 +54908,48 @@ async function resolvePatterns(config2, cwd, outputs = []) {
   const globs = include.filter((p) => !isGitSource(p));
   const internalPatterns = globs.filter((p) => !isExternalPattern(p));
   if (internalPatterns.length > 0) {
-    const { ignore: gitignore, globPatterns } = await loadGitignore(cwd);
+    const { ignores, globPatterns } = await loadGitignore(cwd);
     const matches = await import_fast_glob.glob(internalPatterns, {
+      ...GLOB_OPTIONS,
       cwd,
-      onlyFiles: true,
-      dot: true,
       ignore: globPatterns
     });
-    await add(matches.filter((m) => !gitignore.ignores(m)));
+    await add(matches.filter((m) => !ignores(m)));
   }
   const externalPatterns = globs.filter(isExternalPattern);
   if (externalPatterns.length > 0) {
-    await add(await import_fast_glob.glob(externalPatterns, { cwd, onlyFiles: true, dot: true }));
+    await add(await import_fast_glob.glob(externalPatterns, { ...GLOB_OPTIONS, cwd }));
   }
   if (force.length > 0) {
-    await add(await import_fast_glob.glob(force, { cwd, onlyFiles: true, dot: true }));
+    await add(await import_fast_glob.glob(force, { ...GLOB_OPTIONS, cwd }));
   }
   return [...files].sort();
 }
+function getLinear(config2) {
+  if (typeof config2 === "object" && !Array.isArray(config2)) {
+    return config2.linear;
+  }
+  return;
+}
+async function resolveEntries(config2, cwd, outputs = []) {
+  const linearSource = getLinear(config2);
+  const paths = await resolvePatterns(config2, cwd, outputs);
+  const entries = paths.map((path) => ({ path }));
+  if (linearSource) {
+    const { exclude } = normalizePatterns(config2);
+    const excludeMatchers = exclude.map((p) => import_picomatch.default(p));
+    const taken = new Set(paths.map((path) => resolve2(cwd, path)));
+    for (const entry of await resolveLinearSource(linearSource)) {
+      if (isExcluded(entry.path, excludeMatchers))
+        continue;
+      if (taken.has(resolve2(cwd, entry.path))) {
+        throw new ConfigError(`Linear issue collides with the file "${entry.path}". ` + "Rename the file, or narrow the include patterns so it isn't matched.");
+      }
+      entries.push(entry);
+    }
+  }
+  return entries.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
 function countLines(content) {
   if (content === "")
     return 0;
@@ -54634,28 +54975,29 @@ function formatIndex(index) {
 function formatSeparator(index, filePath) {
   return `#==> [${index}] ${filePath} <==`;
 }
-async function createBundle(files, cwd, options = {}) {
+async function createBundle(entries, cwd, options = {}) {
   const { includeIndex = true } = options;
   const prompt = options.prompt?.trim() || undefined;
   const index = [];
   const contentParts = [];
   let currentLine = 1;
-  for (let i = 0;i < files.length; i++) {
-    const filePath = files[i];
-    const content2 = await readFile(resolve2(cwd, filePath), "utf-8");
+  for (let i = 0;i < entries.length; i++) {
+    const entry = entries[i];
+    const filePath = entry.path;
+    const content2 = entry.content ?? await readFile(resolve2(cwd, filePath), "utf-8");
     const lines = countLines(content2);
     const contentStartLine = currentLine + 1;
-    const entry = {
+    const indexEntry = {
       path: filePath,
       lines,
       startLine: contentStartLine,
       endLine: contentStartLine + Math.max(0, lines - 1)
     };
-    index.push(entry);
+    index.push(indexEntry);
     contentParts.push(formatSeparator(i + 1, filePath));
     contentParts.push(content2.endsWith(`
 `) ? content2.slice(0, -1) : content2);
-    currentLine = entry.endLine + 1;
+    currentLine = indexEntry.endLine + 1;
   }
   const promptLines = prompt ? countLines(prompt) + 3 : 0;
   if (includeIndex) {
@@ -54720,10 +55062,10 @@ async function resolvePrompt(prompt, cwd) {
   return prompt.trim() || undefined;
 }
 async function bundleOne(config2, cwd, outputs = []) {
-  const files = await resolvePatterns(config2, cwd, outputs);
+  const entries = await resolveEntries(config2, cwd, outputs);
   const includeIndex = getIncludeIndex(config2);
   const prompt = await resolvePrompt(getPrompt(config2), cwd);
-  return createBundle(files, cwd, { includeIndex, prompt });
+  return createBundle(entries, cwd, { includeIndex, prompt });
 }
 
 // src/gdrive.ts
@@ -54733,7 +55075,7 @@ import { spawn } from "node:child_process";
 import { createReadStream as createReadStream2 } from "node:fs";
 import { chmod, mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname2, join as join4, basename as basename2 } from "node:path";
+import { dirname as dirname3, join as join4, basename as basename2 } from "node:path";
 
 // node_modules/oauth-callback/dist/index.js
 import fs2 from "node:fs";
@@ -61115,7 +61457,7 @@ async function readCredentials() {
   }
 }
 async function writeCredentials(creds) {
-  await mkdir2(dirname2(CREDENTIALS_PATH), { recursive: true, mode: 448 });
+  await mkdir2(dirname3(CREDENTIALS_PATH), { recursive: true, mode: 448 });
   await writeFile2(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), {
     mode: 384
   });
@@ -62717,21 +63059,69 @@ function formatNumber(n2) {
 function plural(n2, singular, pluralForm) {
   return n2 === 1 ? singular : pluralForm ?? singular + "s";
 }
+var DEFAULT_OUT_DIR = ".srcpack";
+async function physicalPath(path3) {
+  try {
+    return await realpath(path3);
+  } catch {
+    const parent = dirname4(path3);
+    if (parent === path3)
+      return path3;
+    return join6(await physicalPath(parent), basename3(path3));
+  }
+}
+async function entryPath(path3) {
+  return join6(await physicalPath(dirname4(path3)), basename3(path3));
+}
 function isInside(path3, dir) {
   const rel = relative(dir, path3);
   return rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute2(rel);
 }
+async function writeBundle(path3, content) {
+  const temp = `${path3}.${process.pid}.tmp`;
+  try {
+    await writeFile4(temp, content);
+    await rename2(temp, path3);
+  } finally {
+    await rm(temp, { force: true });
+  }
+}
 async function emptyDirectory(dir, skip = []) {
   let entries;
   try {
     entries = await readdir(dir);
-  } catch {
-    return;
+  } catch (error53) {
+    if (error53.code === "ENOENT")
+      return;
+    throw new ConfigError(`Cannot empty outDir "${dir}": ${error53.message}`);
   }
   const skipSet = new Set(skip);
   await Promise.all(entries.filter((entry) => !skipSet.has(entry)).map((entry) => rm(join6(dir, entry), { recursive: true, force: true })));
 }
 var AD_HOC_FLAGS = ["--staged", "--dirty", "--since"];
+var KNOWN_FLAGS = new Set([
+  ...AD_HOC_FLAGS,
+  "--dry-run",
+  "--emptyOutDir",
+  "--no-emptyOutDir",
+  "--no-upload",
+  "--help",
+  "-h",
+  "--version",
+  "-v"
+]);
+function assertKnownFlags(args) {
+  const unknown3 = args.find((arg) => arg.startsWith("-") && !KNOWN_FLAGS.has(arg));
+  if (unknown3) {
+    console.error(`Unknown option: ${unknown3}`);
+    console.error("Run `srcpack --help` to see the available options.");
+    process.exit(1);
+  }
+  if (args.includes("--emptyOutDir") && args.includes("--no-emptyOutDir")) {
+    console.error("Cannot combine --emptyOutDir with --no-emptyOutDir.");
+    process.exit(1);
+  }
+}
 function parseAdHocBundle(args) {
   const flags = AD_HOC_FLAGS.filter((flag) => args.includes(flag));
   if (flags.length > 1) {
@@ -62787,7 +63177,7 @@ Options:
   --dirty          Bundle staged, unstaged, and untracked changes
   --since <rev>    Bundle changes since <rev> (e.g. --since main)
   --dry-run        Preview bundles without writing files
-  --emptyOutDir    Empty output directory before bundling
+  --emptyOutDir    Empty output directory before writing
   --no-emptyOutDir Keep existing files in output directory
   --no-upload      Skip uploading to cloud storage
   -h, --help       Show this help message
@@ -62795,14 +63185,15 @@ Options:
 `);
     return;
   }
-  if (args[0] === "init") {
-    await runInit();
-    return;
-  }
-  if (args[0] === "login") {
-    await runLogin();
+  if (args[0] === "init" || args[0] === "login") {
+    if (args.length > 1) {
+      console.error(`srcpack ${args[0]} takes no arguments.`);
+      process.exit(1);
+    }
+    await (args[0] === "init" ? runInit() : runLogin());
     return;
   }
+  assertKnownFlags(args);
   const dryRun = args.includes("--dry-run");
   const noUpload = args.includes("--no-upload");
   const emptyOutDirFlag = args.includes("--emptyOutDir") ? true : args.includes("--no-emptyOutDir") ? false : undefined;
@@ -62825,7 +63216,7 @@ Options:
   const bundles = adHoc ? { [adHoc.name]: adHoc.patterns } : config3.bundles;
   const bundleNames = requestedBundles.length ? requestedBundles : Object.keys(bundles);
   for (const name of bundleNames) {
-    if (!(name in bundles)) {
+    if (!Object.hasOwn(bundles, name)) {
       console.error(`Unknown bundle: ${name}`);
       process.exit(1);
     }
@@ -62835,22 +63226,38 @@ Options:
     return;
   }
   const root = config3.root;
+  const rootPath = await physicalPath(root);
   const outDirPath = resolve3(root, config3.outDir);
-  const outDirInsideRoot = isInside(outDirPath, root);
-  const emptyOutDir = emptyOutDirFlag ?? (adHoc ? false : config3.emptyOutDir ?? outDirInsideRoot);
-  if (!adHoc && !outDirInsideRoot && emptyOutDirFlag === undefined && config3.emptyOutDir === undefined) {
-    console.warn(`Warning: outDir "${config3.outDir}" is outside project root. ` + "Use --emptyOutDir to suppress this warning and empty the directory.");
-  }
-  const outDirHoldsRoot = isInside(root, outDirPath);
+  const outDirPhysical = await physicalPath(outDirPath);
+  const defaultOutDir = join6(rootPath, DEFAULT_OUT_DIR);
+  if (resolve3(root, DEFAULT_OUT_DIR) === outDirPath && outDirPhysical !== defaultOutDir) {
+    throw new ConfigError(`Refusing to use "${DEFAULT_OUT_DIR}": it resolves to "${outDirPhysical}", not "${defaultOutDir}". ` + "Set outDir to that path explicitly if that is where bundles belong.");
+  }
+  const ownsOutDir = outDirPhysical === defaultOutDir;
+  const emptyOutDir = emptyOutDirFlag ?? (adHoc ? false : config3.emptyOutDir ?? ownsOutDir);
+  const outDirHoldsRoot = isInside(rootPath, outDirPhysical);
   if (emptyOutDir && outDirHoldsRoot) {
     throw new ConfigError(`Refusing to empty outDir "${config3.outDir}": it contains the project root. ` + "Use a subdirectory, or set emptyOutDir: false.");
   }
-  if (emptyOutDir && !dryRun && requestedBundles.length === 0) {
-    await emptyDirectory(outDirPath, [".git"]);
+  const ownOutputs = new Set;
+  const writers = new Map;
+  for (const [name, bundleConfig] of Object.entries(config3.bundles)) {
+    const outfile = resolve3(root, getOutfile(bundleConfig, name, config3.outDir));
+    const entry = await entryPath(outfile);
+    const key = pathKey(entry);
+    const first = writers.get(key);
+    if (first) {
+      throw new ConfigError(`Bundles "${first}" and "${name}" both write to "${relative(root, outfile) || outfile}". ` + "Give one of them its own outfile.");
+    }
+    writers.set(key, name);
+    ownOutputs.add(outfile);
+    ownOutputs.add(entry);
   }
-  const ownOutputs = Object.entries(config3.bundles).map(([name, bundleConfig]) => resolve3(root, getOutfile(bundleConfig, name, config3.outDir)));
-  if (!outDirHoldsRoot)
-    ownOutputs.push(outDirPath);
+  if (!outDirHoldsRoot) {
+    ownOutputs.add(outDirPath);
+    ownOutputs.add(outDirPhysical);
+  }
+  const outputPaths = [...ownOutputs];
   const outputs = [];
   const bundleSpinner = ora({
     text: `Bundling ${bundleNames[0]}...`,
@@ -62861,13 +63268,24 @@ Options:
       const name = bundleNames[i3];
       bundleSpinner.text = `Bundling ${name}... (${i3 + 1}/${bundleNames.length})`;
       const bundleConfig = bundles[name];
-      const result = await bundleOne(bundleConfig, root, ownOutputs);
+      let result;
+      try {
+        result = await bundleOne(bundleConfig, root, outputPaths);
+      } catch (error53) {
+        if (error53 instanceof ConfigError || error53 instanceof GitError || error53 instanceof LinearError) {
+          error53.message = `Bundle "${name}": ${error53.message}`;
+        }
+        throw error53;
+      }
       const outfile = getOutfile(bundleConfig, name, config3.outDir);
       outputs.push({ name, outfile, result });
     }
   } finally {
     bundleSpinner.stop();
   }
+  if (emptyOutDir && !dryRun && requestedBundles.length === 0) {
+    await emptyDirectory(outDirPath, [".git"]);
+  }
   const maxNameLen = Math.max(...outputs.map((o2) => o2.name.length));
   const maxFilesLen = Math.max(...outputs.map((o2) => formatNumber(o2.result.index.length).length));
   const maxLinesLen = Math.max(...outputs.map((o2) => formatNumber(sumLines(o2.result)).length));
@@ -62890,8 +63308,8 @@ Options:
       }
       console.log(`  ${nameCol}  ${filesCol} ${plural(fileCount, "file")}  ${linesCol} ${plural(lineCount, "line")}  → skipped`);
     } else {
-      await mkdir3(dirname3(outPath), { recursive: true });
-      await writeFile4(outPath, result.content);
+      await mkdir3(dirname4(outPath), { recursive: true });
+      await writeBundle(outPath, result.content);
       const displayPath = relative(process.cwd(), outPath);
       console.log(`  ${nameCol}  ${filesCol} ${plural(fileCount, "file")}  ${linesCol} ${plural(lineCount, "line")}  → ${displayPath}`);
     }
@@ -63027,6 +63445,6 @@ function getOutfile(bundleConfig, name, outDir) {
   return join6(outDir, `${name}.txt`);
 }
 main().catch((err) => {
-  console.error(err instanceof ConfigError || err instanceof GitError ? err.message : err);
+  console.error(err instanceof ConfigError || err instanceof GitError || err instanceof LinearError ? err.message : err);
   process.exit(1);
 });