@poe-platform/safe-bash 0.1.710 → 0.1.712

package/dist/safe-bash-command-fmt/index.js

@@ -0,0 +1,2419 @@
+// packages/safe-bash-command-fmt/dist/contracts.js
+var fmtBaseline = Object.freeze({
+  release: "GNU coreutils 9.10",
+  archiveSha256: "16535a9adf0b10037364e2d612aad3d9f4eca3a344949ced74d12faf4bd51d25",
+  developmentSource: "b25722854370b8206d7f53f8934c36710cdd9974",
+  profile: "gnu-coreutils-9.10-C-bytes"
+});
+var defaultFmtLimits = Object.freeze({
+  inputBytes: 32 * 1024 * 1024,
+  outputBytes: 32 * 1024 * 1024,
+  retainedBytes: 80 * 1024,
+  work: 128 * 1024 * 1024,
+  argumentBytes: 65536
+});
+var FmtError = class extends Error {
+  code;
+  usage;
+  constructor(code, message, usage = false) {
+    super(message);
+    this.code = code;
+    this.usage = usage;
+    this.name = "FmtError";
+  }
+};
+function validateFmtLimits(limits) {
+  for (const value of Object.values(limits))
+    if (!Number.isSafeInteger(value) || value < 0)
+      throw new FmtError("LIMIT", "Limits must be nonnegative safe integers");
+  for (const key of ["inputBytes", "outputBytes", "retainedBytes", "work", "argumentBytes"])
+    if (limits[key] === void 0)
+      throw new FmtError("LIMIT", `Missing ${key} limit`);
+}
+function validateFmtProfile(profile) {
+  if (profile !== fmtBaseline.profile && profile !== "gnu-coreutils-8.30-C-bytes")
+    throw new FmtError("PROFILE", "Unavailable fmt byte/locale profile");
+}
+
+// packages/safe-bash-command-fmt/dist/bytes.js
+var prototype = Object.getPrototypeOf(Uint8Array.prototype);
+var tag = Object.getOwnPropertyDescriptor(prototype, Symbol.toStringTag).get;
+var length = Object.getOwnPropertyDescriptor(prototype, "byteLength").get;
+var buffer = Object.getOwnPropertyDescriptor(prototype, "buffer").get;
+var byteOffset = Object.getOwnPropertyDescriptor(prototype, "byteOffset").get;
+var values = Uint8Array.prototype.values;
+function byteView(input) {
+  try {
+    if (tag.call(input) !== "Uint8Array")
+      throw new Error();
+    return { length: length.call(input), values: values.call(input) };
+  } catch {
+    throw new FmtError("INPUT", "Input must be an available Uint8Array byte view");
+  }
+}
+function ownedBytes(input, maximum) {
+  const view = byteView(input);
+  if (view.length > maximum)
+    throw new FmtError("LIMIT", "Argument byte limit exceeded");
+  const result = new Uint8Array(view.length);
+  let offset = 0;
+  for (const byte of view.values)
+    result[offset++] = byte;
+  return result;
+}
+function byteSpan(input, offset, count) {
+  return new Uint8Array(buffer.call(input), byteOffset.call(input) + offset, count);
+}
+
+// packages/safe-bash-command-fmt/dist/quoting.js
+var glibc231PrintableRanges = [
+  32,
+  126,
+  160,
+  887,
+  890,
+  895,
+  900,
+  906,
+  908,
+  908,
+  910,
+  929,
+  931,
+  1327,
+  1329,
+  1366,
+  1369,
+  1375,
+  1377,
+  1415,
+  1417,
+  1418,
+  1421,
+  1423,
+  1425,
+  1479,
+  1488,
+  1514,
+  1520,
+  1524,
+  1536,
+  1564,
+  1566,
+  1805,
+  1807,
+  1866,
+  1869,
+  1969,
+  1984,
+  2042,
+  2048,
+  2093,
+  2096,
+  2110,
+  2112,
+  2139,
+  2142,
+  2142,
+  2208,
+  2228,
+  2230,
+  2237,
+  2260,
+  2435,
+  2437,
+  2444,
+  2447,
+  2448,
+  2451,
+  2472,
+  2474,
+  2480,
+  2482,
+  2482,
+  2486,
+  2489,
+  2492,
+  2500,
+  2503,
+  2504,
+  2507,
+  2510,
+  2519,
+  2519,
+  2524,
+  2525,
+  2527,
+  2531,
+  2534,
+  2555,
+  2561,
+  2563,
+  2565,
+  2570,
+  2575,
+  2576,
+  2579,
+  2600,
+  2602,
+  2608,
+  2610,
+  2611,
+  2613,
+  2614,
+  2616,
+  2617,
+  2620,
+  2620,
+  2622,
+  2626,
+  2631,
+  2632,
+  2635,
+  2637,
+  2641,
+  2641,
+  2649,
+  2652,
+  2654,
+  2654,
+  2662,
+  2677,
+  2689,
+  2691,
+  2693,
+  2701,
+  2703,
+  2705,
+  2707,
+  2728,
+  2730,
+  2736,
+  2738,
+  2739,
+  2741,
+  2745,
+  2748,
+  2757,
+  2759,
+  2761,
+  2763,
+  2765,
+  2768,
+  2768,
+  2784,
+  2787,
+  2790,
+  2801,
+  2809,
+  2809,
+  2817,
+  2819,
+  2821,
+  2828,
+  2831,
+  2832,
+  2835,
+  2856,
+  2858,
+  2864,
+  2866,
+  2867,
+  2869,
+  2873,
+  2876,
+  2884,
+  2887,
+  2888,
+  2891,
+  2893,
+  2902,
+  2903,
+  2908,
+  2909,
+  2911,
+  2915,
+  2918,
+  2935,
+  2946,
+  2947,
+  2949,
+  2954,
+  2958,
+  2960,
+  2962,
+  2965,
+  2969,
+  2970,
+  2972,
+  2972,
+  2974,
+  2975,
+  2979,
+  2980,
+  2984,
+  2986,
+  2990,
+  3001,
+  3006,
+  3010,
+  3014,
+  3016,
+  3018,
+  3021,
+  3024,
+  3024,
+  3031,
+  3031,
+  3046,
+  3066,
+  3072,
+  3075,
+  3077,
+  3084,
+  3086,
+  3088,
+  3090,
+  3112,
+  3114,
+  3129,
+  3133,
+  3140,
+  3142,
+  3144,
+  3146,
+  3149,
+  3157,
+  3158,
+  3160,
+  3162,
+  3168,
+  3171,
+  3174,
+  3183,
+  3192,
+  3203,
+  3205,
+  3212,
+  3214,
+  3216,
+  3218,
+  3240,
+  3242,
+  3251,
+  3253,
+  3257,
+  3260,
+  3268,
+  3270,
+  3272,
+  3274,
+  3277,
+  3285,
+  3286,
+  3294,
+  3294,
+  3296,
+  3299,
+  3302,
+  3311,
+  3313,
+  3314,
+  3329,
+  3331,
+  3333,
+  3340,
+  3342,
+  3344,
+  3346,
+  3386,
+  3389,
+  3396,
+  3398,
+  3400,
+  3402,
+  3407,
+  3412,
+  3427,
+  3430,
+  3455,
+  3458,
+  3459,
+  3461,
+  3478,
+  3482,
+  3505,
+  3507,
+  3515,
+  3517,
+  3517,
+  3520,
+  3526,
+  3530,
+  3530,
+  3535,
+  3540,
+  3542,
+  3542,
+  3544,
+  3551,
+  3558,
+  3567,
+  3570,
+  3572,
+  3585,
+  3642,
+  3647,
+  3675,
+  3713,
+  3714,
+  3716,
+  3716,
+  3719,
+  3720,
+  3722,
+  3722,
+  3725,
+  3725,
+  3732,
+  3735,
+  3737,
+  3743,
+  3745,
+  3747,
+  3749,
+  3749,
+  3751,
+  3751,
+  3754,
+  3755,
+  3757,
+  3769,
+  3771,
+  3773,
+  3776,
+  3780,
+  3782,
+  3782,
+  3784,
+  3789,
+  3792,
+  3801,
+  3804,
+  3807,
+  3840,
+  3911,
+  3913,
+  3948,
+  3953,
+  3991,
+  3993,
+  4028,
+  4030,
+  4044,
+  4046,
+  4058,
+  4096,
+  4293,
+  4295,
+  4295,
+  4301,
+  4301,
+  4304,
+  4680,
+  4682,
+  4685,
+  4688,
+  4694,
+  4696,
+  4696,
+  4698,
+  4701,
+  4704,
+  4744,
+  4746,
+  4749,
+  4752,
+  4784,
+  4786,
+  4789,
+  4792,
+  4798,
+  4800,
+  4800,
+  4802,
+  4805,
+  4808,
+  4822,
+  4824,
+  4880,
+  4882,
+  4885,
+  4888,
+  4954,
+  4957,
+  4988,
+  4992,
+  5017,
+  5024,
+  5109,
+  5112,
+  5117,
+  5120,
+  5788,
+  5792,
+  5880,
+  5888,
+  5900,
+  5902,
+  5908,
+  5920,
+  5942,
+  5952,
+  5971,
+  5984,
+  5996,
+  5998,
+  6e3,
+  6002,
+  6003,
+  6016,
+  6109,
+  6112,
+  6121,
+  6128,
+  6137,
+  6144,
+  6158,
+  6160,
+  6169,
+  6176,
+  6263,
+  6272,
+  6314,
+  6320,
+  6389,
+  6400,
+  6430,
+  6432,
+  6443,
+  6448,
+  6459,
+  6464,
+  6464,
+  6468,
+  6509,
+  6512,
+  6516,
+  6528,
+  6571,
+  6576,
+  6601,
+  6608,
+  6618,
+  6622,
+  6683,
+  6686,
+  6750,
+  6752,
+  6780,
+  6783,
+  6793,
+  6800,
+  6809,
+  6816,
+  6829,
+  6832,
+  6846,
+  6912,
+  6987,
+  6992,
+  7036,
+  7040,
+  7155,
+  7164,
+  7223,
+  7227,
+  7241,
+  7245,
+  7304,
+  7360,
+  7367,
+  7376,
+  7414,
+  7416,
+  7417,
+  7424,
+  7669,
+  7675,
+  7957,
+  7960,
+  7965,
+  7968,
+  8005,
+  8008,
+  8013,
+  8016,
+  8023,
+  8025,
+  8025,
+  8027,
+  8027,
+  8029,
+  8029,
+  8031,
+  8061,
+  8064,
+  8116,
+  8118,
+  8132,
+  8134,
+  8147,
+  8150,
+  8155,
+  8157,
+  8175,
+  8178,
+  8180,
+  8182,
+  8190,
+  8192,
+  8231,
+  8234,
+  8292,
+  8294,
+  8305,
+  8308,
+  8334,
+  8336,
+  8348,
+  8352,
+  8382,
+  8400,
+  8432,
+  8448,
+  8587,
+  8592,
+  9214,
+  9216,
+  9254,
+  9280,
+  9290,
+  9312,
+  11123,
+  11126,
+  11157,
+  11160,
+  11193,
+  11197,
+  11208,
+  11210,
+  11217,
+  11244,
+  11247,
+  11264,
+  11310,
+  11312,
+  11358,
+  11360,
+  11507,
+  11513,
+  11557,
+  11559,
+  11559,
+  11565,
+  11565,
+  11568,
+  11623,
+  11631,
+  11632,
+  11647,
+  11670,
+  11680,
+  11686,
+  11688,
+  11694,
+  11696,
+  11702,
+  11704,
+  11710,
+  11712,
+  11718,
+  11720,
+  11726,
+  11728,
+  11734,
+  11736,
+  11742,
+  11744,
+  11844,
+  11904,
+  11929,
+  11931,
+  12019,
+  12032,
+  12245,
+  12272,
+  12283,
+  12288,
+  12351,
+  12353,
+  12438,
+  12441,
+  12543,
+  12549,
+  12589,
+  12593,
+  12686,
+  12688,
+  12730,
+  12736,
+  12771,
+  12784,
+  12830,
+  12832,
+  13054,
+  13056,
+  19893,
+  19904,
+  40917,
+  40960,
+  42124,
+  42128,
+  42182,
+  42192,
+  42539,
+  42560,
+  42743,
+  42752,
+  42926,
+  42928,
+  42935,
+  42999,
+  43051,
+  43056,
+  43065,
+  43072,
+  43127,
+  43136,
+  43205,
+  43214,
+  43225,
+  43232,
+  43261,
+  43264,
+  43347,
+  43359,
+  43388,
+  43392,
+  43469,
+  43471,
+  43481,
+  43486,
+  43518,
+  43520,
+  43574,
+  43584,
+  43597,
+  43600,
+  43609,
+  43612,
+  43714,
+  43739,
+  43766,
+  43777,
+  43782,
+  43785,
+  43790,
+  43793,
+  43798,
+  43808,
+  43814,
+  43816,
+  43822,
+  43824,
+  43877,
+  43888,
+  44013,
+  44016,
+  44025,
+  44032,
+  55203,
+  55216,
+  55238,
+  55243,
+  55291,
+  57344,
+  64109,
+  64112,
+  64217,
+  64256,
+  64262,
+  64275,
+  64279,
+  64285,
+  64310,
+  64312,
+  64316,
+  64318,
+  64318,
+  64320,
+  64321,
+  64323,
+  64324,
+  64326,
+  64449,
+  64467,
+  64831,
+  64848,
+  64911,
+  64914,
+  64967,
+  65008,
+  65021,
+  65024,
+  65049,
+  65056,
+  65106,
+  65108,
+  65126,
+  65128,
+  65131,
+  65136,
+  65140,
+  65142,
+  65276,
+  65279,
+  65279,
+  65281,
+  65470,
+  65474,
+  65479,
+  65482,
+  65487,
+  65490,
+  65495,
+  65498,
+  65500,
+  65504,
+  65510,
+  65512,
+  65518,
+  65529,
+  65533,
+  65536,
+  65547,
+  65549,
+  65574,
+  65576,
+  65594,
+  65596,
+  65597,
+  65599,
+  65613,
+  65616,
+  65629,
+  65664,
+  65786,
+  65792,
+  65794,
+  65799,
+  65843,
+  65847,
+  65934,
+  65936,
+  65947,
+  65952,
+  65952,
+  66e3,
+  66045,
+  66176,
+  66204,
+  66208,
+  66256,
+  66272,
+  66299,
+  66304,
+  66339,
+  66352,
+  66378,
+  66384,
+  66426,
+  66432,
+  66461,
+  66463,
+  66499,
+  66504,
+  66517,
+  66560,
+  66717,
+  66720,
+  66729,
+  66736,
+  66771,
+  66776,
+  66811,
+  66816,
+  66855,
+  66864,
+  66915,
+  66927,
+  66927,
+  67072,
+  67382,
+  67392,
+  67413,
+  67424,
+  67431,
+  67584,
+  67589,
+  67592,
+  67592,
+  67594,
+  67637,
+  67639,
+  67640,
+  67644,
+  67644,
+  67647,
+  67669,
+  67671,
+  67742,
+  67751,
+  67759,
+  67808,
+  67826,
+  67828,
+  67829,
+  67835,
+  67867,
+  67871,
+  67897,
+  67903,
+  67903,
+  67968,
+  68023,
+  68028,
+  68047,
+  68050,
+  68099,
+  68101,
+  68102,
+  68108,
+  68115,
+  68117,
+  68119,
+  68121,
+  68147,
+  68152,
+  68154,
+  68159,
+  68167,
+  68176,
+  68184,
+  68192,
+  68255,
+  68288,
+  68326,
+  68331,
+  68342,
+  68352,
+  68405,
+  68409,
+  68437,
+  68440,
+  68466,
+  68472,
+  68497,
+  68505,
+  68508,
+  68521,
+  68527,
+  68608,
+  68680,
+  68736,
+  68786,
+  68800,
+  68850,
+  68858,
+  68863,
+  69216,
+  69246,
+  69632,
+  69709,
+  69714,
+  69743,
+  69759,
+  69825,
+  69840,
+  69864,
+  69872,
+  69881,
+  69888,
+  69940,
+  69942,
+  69955,
+  69968,
+  70006,
+  70016,
+  70093,
+  70096,
+  70111,
+  70113,
+  70132,
+  70144,
+  70161,
+  70163,
+  70206,
+  70272,
+  70278,
+  70280,
+  70280,
+  70282,
+  70285,
+  70287,
+  70301,
+  70303,
+  70313,
+  70320,
+  70378,
+  70384,
+  70393,
+  70400,
+  70403,
+  70405,
+  70412,
+  70415,
+  70416,
+  70419,
+  70440,
+  70442,
+  70448,
+  70450,
+  70451,
+  70453,
+  70457,
+  70460,
+  70468,
+  70471,
+  70472,
+  70475,
+  70477,
+  70480,
+  70480,
+  70487,
+  70487,
+  70493,
+  70499,
+  70502,
+  70508,
+  70512,
+  70516,
+  70656,
+  70745,
+  70747,
+  70747,
+  70749,
+  70749,
+  70784,
+  70855,
+  70864,
+  70873,
+  71040,
+  71093,
+  71096,
+  71133,
+  71168,
+  71236,
+  71248,
+  71257,
+  71264,
+  71276,
+  71296,
+  71351,
+  71360,
+  71369,
+  71424,
+  71449,
+  71453,
+  71467,
+  71472,
+  71487,
+  71840,
+  71922,
+  71935,
+  71935,
+  72384,
+  72440,
+  72704,
+  72712,
+  72714,
+  72758,
+  72760,
+  72773,
+  72784,
+  72812,
+  72816,
+  72847,
+  72850,
+  72871,
+  72873,
+  72886,
+  73728,
+  74649,
+  74752,
+  74862,
+  74864,
+  74868,
+  74880,
+  75075,
+  77824,
+  78894,
+  82944,
+  83526,
+  92160,
+  92728,
+  92736,
+  92766,
+  92768,
+  92777,
+  92782,
+  92783,
+  92880,
+  92909,
+  92912,
+  92917,
+  92928,
+  92997,
+  93008,
+  93017,
+  93019,
+  93025,
+  93027,
+  93047,
+  93053,
+  93071,
+  93952,
+  94020,
+  94032,
+  94078,
+  94095,
+  94111,
+  94176,
+  94176,
+  94208,
+  100332,
+  100352,
+  101106,
+  110592,
+  110593,
+  113664,
+  113770,
+  113776,
+  113788,
+  113792,
+  113800,
+  113808,
+  113817,
+  113820,
+  113827,
+  118784,
+  119029,
+  119040,
+  119078,
+  119081,
+  119272,
+  119296,
+  119365,
+  119552,
+  119638,
+  119648,
+  119665,
+  119808,
+  119892,
+  119894,
+  119964,
+  119966,
+  119967,
+  119970,
+  119970,
+  119973,
+  119974,
+  119977,
+  119980,
+  119982,
+  119993,
+  119995,
+  119995,
+  119997,
+  120003,
+  120005,
+  120069,
+  120071,
+  120074,
+  120077,
+  120084,
+  120086,
+  120092,
+  120094,
+  120121,
+  120123,
+  120126,
+  120128,
+  120132,
+  120134,
+  120134,
+  120138,
+  120144,
+  120146,
+  120485,
+  120488,
+  120779,
+  120782,
+  121483,
+  121499,
+  121503,
+  121505,
+  121519,
+  122880,
+  122886,
+  122888,
+  122904,
+  122907,
+  122913,
+  122915,
+  122916,
+  122918,
+  122922,
+  124928,
+  125124,
+  125127,
+  125142,
+  125184,
+  125258,
+  125264,
+  125273,
+  125278,
+  125279,
+  126464,
+  126467,
+  126469,
+  126495,
+  126497,
+  126498,
+  126500,
+  126500,
+  126503,
+  126503,
+  126505,
+  126514,
+  126516,
+  126519,
+  126521,
+  126521,
+  126523,
+  126523,
+  126530,
+  126530,
+  126535,
+  126535,
+  126537,
+  126537,
+  126539,
+  126539,
+  126541,
+  126543,
+  126545,
+  126546,
+  126548,
+  126548,
+  126551,
+  126551,
+  126553,
+  126553,
+  126555,
+  126555,
+  126557,
+  126557,
+  126559,
+  126559,
+  126561,
+  126562,
+  126564,
+  126564,
+  126567,
+  126570,
+  126572,
+  126578,
+  126580,
+  126583,
+  126585,
+  126588,
+  126590,
+  126590,
+  126592,
+  126601,
+  126603,
+  126619,
+  126625,
+  126627,
+  126629,
+  126633,
+  126635,
+  126651,
+  126704,
+  126705,
+  126976,
+  127019,
+  127024,
+  127123,
+  127136,
+  127150,
+  127153,
+  127167,
+  127169,
+  127183,
+  127185,
+  127221,
+  127232,
+  127244,
+  127248,
+  127278,
+  127280,
+  127339,
+  127344,
+  127404,
+  127462,
+  127490,
+  127504,
+  127547,
+  127552,
+  127560,
+  127568,
+  127569,
+  127744,
+  128722,
+  128736,
+  128748,
+  128752,
+  128758,
+  128768,
+  128883,
+  128896,
+  128980,
+  129024,
+  129035,
+  129040,
+  129095,
+  129104,
+  129113,
+  129120,
+  129159,
+  129168,
+  129197,
+  129296,
+  129310,
+  129312,
+  129319,
+  129328,
+  129328,
+  129331,
+  129342,
+  129344,
+  129355,
+  129360,
+  129374,
+  129408,
+  129425,
+  129472,
+  129472,
+  131072,
+  173782,
+  173824,
+  177972,
+  177984,
+  178205,
+  178208,
+  183969,
+  194560,
+  195101,
+  917505,
+  917505,
+  917536,
+  917631,
+  917760,
+  917999,
+  983040,
+  1048573,
+  1048576,
+  1114109
+];
+function unicodeLocale(context) {
+  const locale = (context.env.LC_ALL || context.env.LC_CTYPE || context.env.LANG || "C").toLowerCase();
+  if (locale === "c" || locale === "posix")
+    return false;
+  if (locale === "c.utf-8" || locale === "c.utf8" || locale === "en_us.utf-8" || locale === "en_us.utf8")
+    return true;
+  throw new FmtError("PROFILE", "Unavailable fmt byte/locale profile");
+}
+function quote(bytes, shell, unicode = false) {
+  const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+  const units = [];
+  for (let offset = 0; offset < bytes.length; ) {
+    const first = bytes[offset];
+    let length2 = 1;
+    let text = String.fromCharCode(first);
+    let valid = first < 128;
+    if (unicode && first >= 194 && first <= 244) {
+      const size = first < 224 ? 2 : first < 240 ? 3 : 4;
+      try {
+        text = decoder.decode(bytes.subarray(offset, offset + size));
+        length2 = size;
+        valid = true;
+      } catch {
+        valid = false;
+      }
+    }
+    units.push({ text, bytes: bytes.subarray(offset, offset + length2), valid });
+    offset += length2;
+  }
+  const escapes = { "\x07": "\\a", "\b": "\\b", "	": "\\t", "\n": "\\n", "\v": "\\v", "\f": "\\f", "\r": "\\r" };
+  const printable = (unit) => {
+    if (!unit.valid)
+      return false;
+    const point = unit.text.codePointAt(0);
+    if (point < 128)
+      return point >= 32 && point < 127;
+    if (!unicode)
+      return false;
+    let low = 0;
+    let high = glibc231PrintableRanges.length / 2;
+    while (low < high) {
+      const middle = Math.trunc((low + high) / 2);
+      if (point < glibc231PrintableRanges[middle * 2])
+        high = middle;
+      else if (point > glibc231PrintableRanges[middle * 2 + 1])
+        low = middle + 1;
+      else
+        return true;
+    }
+    return false;
+  };
+  if (shell && bytes.includes(39) && units.every((unit, index) => printable(unit) && !'!"$&()*;<=>?[^`|\\{}'.includes(unit.text) && (index === 0 || !"#~".includes(unit.text))))
+    return `"${units.map((unit) => unit.text).join("")}"`;
+  const left = !shell && unicode ? "\u2018" : "'";
+  const right = !shell && unicode ? "\u2019" : "'";
+  let result = left;
+  let escaping = shell && bytes.includes(39) && units.length > 0 && !printable(units[units.length - 1]);
+  for (const unit of units) {
+    if (shell && unit.text === "'") {
+      result += "'\\''";
+      escaping = false;
+    } else if (!printable(unit)) {
+      if (shell && !escaping)
+        result += "'$'";
+      escaping = true;
+      result += escapes[unit.text] ?? Array.from(unit.bytes, (byte) => `\\${byte.toString(8).padStart(3, "0")}`).join("");
+    } else {
+      if (shell && escaping)
+        result += "''";
+      escaping = false;
+      if (!shell && (unit.text === right || unit.text === "\\"))
+        result += "\\";
+      result += unit.text;
+    }
+  }
+  return result + right;
+}
+
+// packages/safe-bash-command-fmt/dist/arguments.js
+function optionError(message) {
+  throw new FmtError("OPTION", message, true);
+}
+function widthValue(text, maximum, unicode, profile, goal = false) {
+  let offset = 0;
+  while (text.charCodeAt(offset) === 32 || text.charCodeAt(offset) >= 9 && text.charCodeAt(offset) <= 13)
+    offset++;
+  if (text[offset] === "+")
+    offset++;
+  const start = offset;
+  let number = 0;
+  while (text.charCodeAt(offset) >= 48 && text.charCodeAt(offset) <= 57) {
+    number = Math.min(1073741824, number * 10 + text.charCodeAt(offset++) - 48);
+  }
+  if (offset === start || offset !== text.length || number > maximum) {
+    const range = offset === text.length && offset !== start && number > maximum;
+    const overflow = profile === "gnu-coreutils-8.30-C-bytes" ? number > 1073741823 : goal;
+    throw new FmtError("WIDTH", `invalid width: ${quote(Uint8Array.from(text, (unit) => unit.charCodeAt(0)), false, unicode)}${range ? overflow ? ": Value too large for defined data type" : ": Numerical result out of range" : ""}`);
+  }
+  return number;
+}
+function parseFmtArguments(input, configuration = {}) {
+  const limits = configuration.limits ?? defaultFmtLimits;
+  validateFmtLimits(limits);
+  const profile = configuration.profile ?? fmtBaseline.profile;
+  validateFmtProfile(profile);
+  if (input.length > 4096)
+    throw new FmtError("LIMIT", "argument count limit exceeded");
+  let size = 0;
+  const bytes = input.map((value) => {
+    const copy = ownedBytes(value, limits.argumentBytes - size);
+    size += copy.length;
+    return copy;
+  });
+  const names = bytes.map((value) => new TextDecoder("utf-8", { ignoreBOM: true }).decode(value));
+  const args = bytes.map((value) => Array.from(value, (byte) => String.fromCharCode(byte)).join(""));
+  const settings = { profile, width: 75, goal: 70, crown: false, tagged: false, split: false, uniform: false, prefix: new Uint8Array(), leading: 0, fullPrefix: 0, files: [] };
+  let width;
+  let goal;
+  let stopped = false;
+  const long = { "crown-margin": "c", prefix: "p", "split-only": "s", "tagged-paragraph": "t", "uniform-spacing": "u", width: "w", goal: "g", help: "help", version: "version" };
+  let index = 0;
+  const first = args[0];
+  if (first?.startsWith("-") && first.charCodeAt(1) >= 48 && first.charCodeAt(1) <= 57) {
+    width = first.slice(1);
+    index++;
+  }
+  for (; index < args.length; index++) {
+    const argument = args[index];
+    if (stopped || !argument.startsWith("-") || argument === "-") {
+      settings.files.push({ name: names[index], bytes: bytes[index] });
+      if (configuration.posixlyCorrect === true)
+        stopped = true;
+      continue;
+    }
+    if (argument === "--") {
+      stopped = true;
+      continue;
+    }
+    const expanded = [];
+    if (argument.startsWith("--")) {
+      const equals = argument.indexOf("=");
+      const name = argument.slice(2, equals < 0 ? void 0 : equals);
+      const matches = Object.keys(long).filter((key2) => key2.startsWith(name));
+      const selected = Object.hasOwn(long, name) ? name : matches.length === 1 ? matches[0] : void 0;
+      if (!selected) {
+        if (matches.length > 1)
+          optionError(`option '${argument}' is ambiguous; possibilities: ${matches.map((key2) => `'--${key2}'`).join(" ")}`);
+        optionError(`unrecognized option '${argument}'`);
+      }
+      const key = long[selected];
+      let value;
+      let position = index;
+      if ("pwg".includes(key)) {
+        value = equals < 0 ? args[++index] : argument.slice(equals + 1);
+        position = index;
+        if (value === void 0)
+          optionError(`option '--${selected}' requires an argument`);
+      } else if (equals >= 0)
+        optionError(`option '--${selected}' doesn't allow an argument`);
+      expanded.push({ key, ...value === void 0 ? {} : { value }, position, valueOffset: equals < 0 ? 0 : equals + 1 });
+    } else {
+      for (let offset = 1; offset < argument.length; offset++) {
+        const key = argument[offset];
+        if (key >= "0" && key <= "9")
+          optionError(`invalid option -- ${key}; -WIDTH is recognized only when it is the first
+option; use -w N instead`);
+        if (!"cstuwpg".includes(key))
+          optionError(`invalid option -- '${key}'`);
+        let value;
+        let valueOffset = 0;
+        if ("pwg".includes(key)) {
+          if (offset + 1 < argument.length)
+            valueOffset = offset + 1;
+          value = argument.slice(offset + 1) || args[++index];
+          if (value === void 0)
+            optionError(`option requires an argument -- '${key}'`);
+          offset = argument.length;
+        }
+        expanded.push({ key, ...value === void 0 ? {} : { value }, position: index, valueOffset });
+      }
+    }
+    for (const option of expanded) {
+      switch (option.key) {
+        case "c":
+          settings.crown = true;
+          break;
+        case "t":
+          settings.tagged = true;
+          break;
+        case "s":
+          settings.split = true;
+          break;
+        case "u":
+          settings.uniform = true;
+          break;
+        case "w":
+          width = option.value;
+          break;
+        case "g":
+          goal = option.value;
+          break;
+        case "help":
+        case "version":
+          settings.information = option.key;
+          return settings;
+        case "p": {
+          const prefixBytes = bytes[option.position].subarray(option.valueOffset);
+          let start = 0;
+          let end = prefixBytes.indexOf(0);
+          if (end < 0)
+            end = prefixBytes.length;
+          while (start < end && prefixBytes[start] === 32)
+            start++;
+          settings.leading = start;
+          settings.fullPrefix = end - start;
+          while (end > start && prefixBytes[end - 1] === 32)
+            end--;
+          settings.prefix = new Uint8Array(prefixBytes.subarray(start, end));
+          break;
+        }
+      }
+    }
+  }
+  const unicode = configuration.unicodeQuotes ?? false;
+  if (width !== void 0)
+    settings.width = widthValue(width, 2500, unicode, profile);
+  if (goal !== void 0) {
+    settings.goal = widthValue(goal, settings.width, unicode, profile, true);
+    if (width === void 0)
+      settings.width = settings.goal + 10;
+  } else
+    settings.goal = Math.trunc(settings.width * 187 / 200);
+  if (!settings.files.length)
+    settings.files.push({ name: "-", bytes: Uint8Array.of(45) });
+  return settings;
+}
+
+// packages/safe-bash-command-fmt/dist/engine.js
+var WorkBudget = class {
+  limits;
+  signal;
+  operations = 0;
+  output = 0;
+  input = 0;
+  closed = false;
+  sinceCheckpoint = 0;
+  constructor(limits, signal) {
+    this.limits = limits;
+    this.signal = signal;
+  }
+  check() {
+    if (this.closed)
+      throw new FmtError("CLOSED", "fmt engine is closed");
+    if (this.signal.aborted)
+      throw new FmtError("CANCELLED", "fmt engine cancelled");
+  }
+  *step(count = 1) {
+    this.charge(count);
+    if (this.sinceCheckpoint >= 1024) {
+      this.sinceCheckpoint = 0;
+      if ((yield void 0) !== void 0)
+        throw new FmtError("INPUT", "Unexpected input on fmt checkpoint event");
+    }
+    this.check();
+  }
+  charge(count) {
+    this.check();
+    if (count > this.limits.work - this.operations)
+      throw new FmtError("LIMIT", "work limit exceeded");
+    this.operations += count;
+    this.sinceCheckpoint += count;
+  }
+  admitInput(size) {
+    this.check();
+    if (size > 4096 || size > this.limits.inputBytes - this.input)
+      throw new FmtError("LIMIT", "input byte or bounded-call limit exceeded");
+    this.input += size;
+  }
+  admitOutput() {
+    if (this.output === this.limits.outputBytes)
+      throw new FmtError("LIMIT", "output limit exceeded");
+    this.output++;
+  }
+  exact(value) {
+    if (!Number.isSafeInteger(value))
+      throw new FmtError("ARITHMETIC", "fmt exact arithmetic limit exceeded");
+    return value;
+  }
+};
+var Formatter = class {
+  settings;
+  budget;
+  chunk = new Uint8Array(4096);
+  chunkUsed = 0;
+  offset = 0;
+  eof = false;
+  pending = new Uint8Array(1024);
+  pendingUsed = 0;
+  text = new Uint8Array(5e3);
+  used = 0;
+  words = [];
+  costs = [];
+  breaks = [];
+  lengths = [];
+  column = 0;
+  nextPrefix = 0;
+  prefixIndent = 0;
+  firstIndent = 0;
+  otherIndent = 0;
+  lastLength = 0;
+  outColumn = 0;
+  tabs = false;
+  constructor(settings, budget) {
+    this.settings = settings;
+    this.budget = budget;
+  }
+  *read() {
+    yield* this.budget.step();
+    while (this.offset === this.chunkUsed) {
+      if (this.eof)
+        return -1;
+      const incoming = yield "input";
+      this.budget.check();
+      if (incoming === null) {
+        this.eof = true;
+        return -1;
+      }
+      if (incoming === void 0)
+        throw new FmtError("INPUT", "Expected input bytes or null EOF");
+      const view = byteView(incoming);
+      this.budget.charge(view.length + 1);
+      this.budget.admitInput(view.length);
+      let position = 0;
+      for (const byte of view.values)
+        this.chunk[position++] = byte;
+      this.chunkUsed = view.length;
+      this.offset = 0;
+      yield* this.budget.step(0);
+    }
+    return this.chunk[this.offset++];
+  }
+  *emit(byte) {
+    yield* this.budget.step();
+    this.budget.admitOutput();
+    this.pending[this.pendingUsed++] = byte;
+    if (this.pendingUsed === this.pending.length) {
+      if ((yield this.pending.slice()) !== void 0)
+        throw new FmtError("INPUT", "Unexpected input on fmt output event");
+      this.pendingUsed = 0;
+    }
+  }
+  *spaces(count) {
+    const target = this.budget.exact(this.outColumn + count);
+    const tabEnd = Math.trunc(target / 8) * 8;
+    if (this.tabs && this.outColumn + 1 < tabEnd) {
+      while (this.outColumn < tabEnd) {
+        yield* this.emit(9);
+        this.outColumn = (Math.trunc(this.outColumn / 8) + 1) * 8;
+      }
+    }
+    while (this.outColumn < target) {
+      yield* this.emit(32);
+      this.outColumn++;
+    }
+  }
+  *whitespace(byte) {
+    while (byte === 32 || byte === 9) {
+      if (byte === 32)
+        this.column = this.budget.exact(this.column + 1);
+      else {
+        this.tabs = true;
+        this.column = this.budget.exact((Math.trunc(this.column / 8) + 1) * 8);
+      }
+      byte = yield* this.read();
+    }
+    return byte;
+  }
+  *lineStart() {
+    this.column = 0;
+    let byte = yield* this.whitespace(yield* this.read());
+    const { prefix, leading } = this.settings;
+    this.nextPrefix = prefix.length ? this.column : Math.min(leading, this.column);
+    if (prefix.length) {
+      for (const expected of prefix) {
+        if (byte !== expected)
+          return byte;
+        this.column++;
+        byte = yield* this.read();
+      }
+      byte = yield* this.whitespace(byte);
+    }
+    return byte;
+  }
+  compatible(byte) {
+    return byte !== -1 && byte !== 10 && this.nextPrefix === this.prefixIndent && this.column >= this.nextPrefix + this.settings.fullPrefix;
+  }
+  secondary(compatible) {
+    if (this.settings.split)
+      this.otherIndent = this.firstIndent;
+    else if (this.settings.crown)
+      this.otherIndent = compatible ? this.column : this.firstIndent;
+    else if (this.settings.tagged) {
+      if (compatible && this.column !== this.firstIndent)
+        this.otherIndent = this.column;
+      else if (this.otherIndent === this.firstIndent)
+        this.otherIndent = this.firstIndent === 0 ? 3 : 0;
+    } else
+      this.otherIndent = this.firstIndent;
+  }
+  *optimize() {
+    const count = this.words.length;
+    this.costs[count] = 0;
+    for (let start = count - 1; start >= 0; start--) {
+      const word = this.words[start];
+      let penalty = 4900;
+      const previous = this.words[start - 1];
+      if (previous?.period)
+        penalty += previous.final ? -2500 : 36e4;
+      else if (previous?.punctuation)
+        penalty -= 1600;
+      else if (previous && this.words[start - 2]?.final)
+        penalty += Math.trunc(4e4 / (previous.length + 2));
+      if (word.opening)
+        penalty -= 1600;
+      else if (word.final)
+        penalty += Math.trunc(22500 / (word.length + 2));
+      let length2 = (start === 0 ? this.firstIndent : this.otherIndent) + word.length;
+      let best = Infinity;
+      for (let end = start + 1; ; end++) {
+        yield* this.budget.step();
+        let cost = this.costs[end];
+        if (end !== count) {
+          cost += 100 * (this.settings.goal - length2) ** 2;
+          if (this.breaks[end] !== count)
+            cost += 50 * (length2 - this.lengths[end]) ** 2;
+        }
+        if (start === 0 && this.lastLength > 0)
+          cost += 50 * (length2 - this.lastLength) ** 2;
+        this.budget.exact(cost);
+        if (cost < best) {
+          best = cost;
+          this.breaks[start] = end;
+          this.lengths[start] = length2;
+        }
+        if (end === count)
+          break;
+        length2 += this.words[end - 1].space + this.words[end].length;
+        if (this.settings.profile === "gnu-coreutils-8.30-C-bytes" ? length2 >= this.settings.width : length2 > this.settings.width)
+          break;
+      }
+      this.costs[start] = this.budget.exact(best + penalty);
+    }
+  }
+  *render(finish) {
+    for (let start = 0; start < finish; start = this.breaks[start]) {
+      this.outColumn = 0;
+      yield* this.spaces(this.prefixIndent);
+      for (const byte of this.settings.prefix)
+        yield* this.emit(byte);
+      this.outColumn += this.settings.prefix.length;
+      yield* this.spaces((start === 0 ? this.firstIndent : this.otherIndent) - this.outColumn);
+      const end = this.breaks[start];
+      for (let index = start; index < end; index++) {
+        const word = this.words[index];
+        for (let position = word.start; position < word.start + word.length; position++)
+          yield* this.emit(this.text[position]);
+        this.outColumn += word.length;
+        if (index + 1 !== end)
+          yield* this.spaces(word.space);
+      }
+      this.lastLength = this.outColumn;
+      yield* this.emit(10);
+    }
+  }
+  *makeRoom(current) {
+    this.secondary(true);
+    if (!this.words.length) {
+      for (let position = 0; position < this.used; position++)
+        yield* this.emit(this.text[position]);
+      this.used = 0;
+      current.start = 0;
+      return;
+    }
+    yield* this.optimize();
+    let cut = this.words.length;
+    let score = Infinity;
+    for (let line = this.breaks[0]; line !== this.words.length; line = this.breaks[line]) {
+      yield* this.budget.step();
+      const candidate = this.costs[line] - this.costs[this.breaks[line]];
+      if (candidate < score) {
+        cut = line;
+        score = candidate;
+      }
+      score += 9;
+    }
+    yield* this.render(cut);
+    const offset = cut === this.words.length ? current.start : this.words[cut].start;
+    yield* this.budget.step(this.used - offset + this.words.length);
+    this.text.copyWithin(0, offset, this.used);
+    this.used -= offset;
+    this.words = this.words.slice(cut);
+    for (const word of this.words)
+      word.start -= offset;
+    current.start -= offset;
+  }
+  *readLine(byte) {
+    do {
+      const word = { start: this.used, length: 0, space: 0, opening: false, period: false, punctuation: false, final: false };
+      do {
+        if (this.used === this.text.length)
+          yield* this.makeRoom(word);
+        this.text[this.used++] = byte;
+        byte = yield* this.read();
+      } while (byte !== -1 && byte !== 32 && !(byte >= 9 && byte <= 13));
+      word.length = this.used - word.start;
+      this.column = this.budget.exact(this.column + word.length);
+      const first = this.text[word.start];
+      const last = this.text[this.used - 1];
+      word.opening = first === 0 || "(['`\"".includes(String.fromCharCode(first));
+      word.punctuation = last >= 33 && last <= 47 || last >= 58 && last <= 64 || last >= 91 && last <= 96 || last >= 123 && last <= 126;
+      let terminal = this.used - 1;
+      yield* this.budget.step(word.length);
+      while (terminal > word.start && (this.text[terminal] === 0 || `)]'"`.includes(String.fromCharCode(this.text[terminal]))))
+        terminal--;
+      word.period = this.text[terminal] === 0 || ".?!".includes(String.fromCharCode(this.text[terminal]));
+      const before = this.column;
+      byte = yield* this.whitespace(byte);
+      word.space = this.column - before;
+      word.final = byte === -1 || word.period && (byte === 10 || word.space > 1);
+      if (byte === 10 || byte === -1 || this.settings.uniform)
+        word.space = word.final ? 2 : 1;
+      if (this.words.length === 998)
+        yield* this.makeRoom(word);
+      this.words.push(word);
+    } while (byte !== -1 && byte !== 10);
+    return yield* this.lineStart();
+  }
+  dispose() {
+    this.chunk = new Uint8Array();
+    this.pending = new Uint8Array();
+    this.text = new Uint8Array();
+    this.chunkUsed = this.pendingUsed = this.used = 0;
+    this.words = [];
+    this.costs = [];
+    this.breaks = [];
+    this.lengths = [];
+    this.settings = { ...this.settings, prefix: new Uint8Array(), files: [] };
+  }
+  *run() {
+    let byte = yield* this.lineStart();
+    while (true) {
+      if (byte === 10 || byte === -1 || this.nextPrefix < this.settings.leading || this.column < this.nextPrefix + this.settings.fullPrefix) {
+        this.outColumn = 0;
+        if (this.column > this.nextPrefix || byte !== 10 && byte !== -1) {
+          yield* this.spaces(this.nextPrefix);
+          for (const prefixByte of this.settings.prefix) {
+            if (this.outColumn === this.column)
+              break;
+            yield* this.emit(prefixByte);
+            this.outColumn++;
+          }
+          if (byte !== -1 && byte !== 10)
+            yield* this.spaces(this.column - this.outColumn);
+          if (byte === -1 && this.column >= this.nextPrefix + this.settings.prefix.length)
+            yield* this.emit(10);
+        }
+        while (byte !== -1 && byte !== 10) {
+          yield* this.emit(byte);
+          byte = yield* this.read();
+        }
+        if (byte === -1)
+          break;
+        yield* this.emit(10);
+        byte = yield* this.lineStart();
+        continue;
+      }
+      this.lastLength = 0;
+      this.prefixIndent = this.nextPrefix;
+      this.firstIndent = this.column;
+      this.words = [];
+      this.used = 0;
+      byte = yield* this.readLine(byte);
+      this.secondary(this.compatible(byte));
+      if (!this.settings.split) {
+        const acceptSecond = this.compatible(byte) && (this.settings.crown || this.settings.tagged ? this.settings.crown || this.column !== this.firstIndent : this.column === this.otherIndent);
+        if (acceptSecond) {
+          do {
+            byte = yield* this.readLine(byte);
+          } while (this.compatible(byte) && this.column === this.otherIndent);
+        }
+      }
+      const last = this.words[this.words.length - 1];
+      last.period = true;
+      last.final = true;
+      yield* this.optimize();
+      yield* this.render(this.words.length);
+    }
+    if (this.pendingUsed) {
+      if ((yield this.pending.slice(0, this.pendingUsed)) !== void 0)
+        throw new FmtError("INPUT", "Unexpected input on fmt output event");
+      this.pendingUsed = 0;
+    }
+  }
+};
+function createFmtEngine(options, limits, signal) {
+  if (signal.aborted)
+    throw new FmtError("CANCELLED", "fmt engine cancelled");
+  validateFmtLimits(limits);
+  validateFmtProfile(options.profile);
+  for (const [value, maximum] of [[options.width, 2500], [options.goal, options.width], [options.leading, limits.argumentBytes], [options.fullPrefix, limits.argumentBytes]]) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > maximum)
+      throw new FmtError("WIDTH", "Invalid fmt width, goal or prefix indentation");
+  }
+  const prefixSize = byteView(options.prefix).length;
+  const retained = 5e3 + 4096 + 1024 + prefixSize;
+  if (retained > limits.retainedBytes)
+    throw new FmtError("LIMIT", "fmt buffer retention limit exceeded");
+  let prefix = ownedBytes(options.prefix, limits.argumentBytes);
+  const budget = new WorkBudget(Object.freeze({ ...limits }), signal);
+  const formatter = new Formatter({ ...options, prefix, files: [] }, budget);
+  let started = false;
+  const dispose = () => {
+    budget.closed = true;
+    formatter.dispose();
+    prefix.fill(0);
+    prefix = new Uint8Array();
+  };
+  return {
+    *run() {
+      if (started)
+        throw new FmtError("CLOSED", "fmt engine has already started");
+      started = true;
+      try {
+        budget.check();
+        yield* formatter.run();
+        budget.check();
+      } finally {
+        dispose();
+      }
+    },
+    dispose,
+    accounting: () => Object.freeze({ inputBytes: budget.input, decodedBytes: 0, outputBytes: budget.output, work: budget.operations, retainedBytes: budget.closed ? 0 : retained, peakRetainedBytes: retained })
+  };
+}
+
+// packages/safe-bash-command-fmt/dist/command.js
+import { commandRuntimeIdentity, CommandArgumentIdentityError, FsError, getCommandArguments, isFsError, readBytes, writeBytes, shellValueByteLength as shellValueByteLength2 } from "../safe-bash-contracts/index.js";
+import { isAbsolutePath, validatePath } from "@poe-platform/safe-fs/core";
+import { assertCommandRequirements } from "../safe-bash-contracts/command-requirements.js";
+import { createOutputOperation } from "../safe-bash-contracts/output.js";
+
+// packages/safe-bash-command-fmt/dist/sdk.js
+import { shellValueByteLength } from "../safe-bash-contracts/value.js";
+var formattingKeys = ["width", "goal", "crown", "tagged", "split", "uniform", "prefix", "files"];
+function captureFmtArguments(options, limits) {
+  const typed = formattingKeys.some((key) => options[key] !== void 0);
+  if (options.arguments !== void 0 && typed)
+    throw new FmtError("OPTION", "SDK arguments cannot be combined with formatting options");
+  if (options.arguments === void 0 && !typed)
+    return void 0;
+  const args = [];
+  let extent = 0;
+  const append = (value) => {
+    if (args.length >= 4096)
+      throw new FmtError("LIMIT", "argument count limit exceeded");
+    let bytes;
+    if (typeof value === "string") {
+      if (value.length > limits.argumentBytes - extent || shellValueByteLength(value) > limits.argumentBytes - extent)
+        throw new FmtError("LIMIT", "Argument byte limit exceeded");
+      bytes = new TextEncoder().encode(value);
+    } else
+      bytes = ownedBytes(value, limits.argumentBytes - extent);
+    extent += bytes.length;
+    args.push(bytes);
+  };
+  if (options.arguments !== void 0) {
+    if (options.arguments.length > 4096)
+      throw new FmtError("LIMIT", "argument count limit exceeded");
+    for (const argument of options.arguments)
+      append(argument);
+  } else {
+    for (const key of ["width", "goal"]) {
+      const value = options[key];
+      if (value !== void 0) {
+        if (!Number.isSafeInteger(value) || value < 0)
+          throw new FmtError("WIDTH", "SDK widths must be nonnegative safe integers");
+        append(key === "width" ? "-w" : "-g");
+        append(String(value));
+      }
+    }
+    for (const [key, flag] of [["crown", "-c"], ["tagged", "-t"], ["split", "-s"], ["uniform", "-u"]]) {
+      const value = options[key];
+      if (value !== void 0 && typeof value !== "boolean")
+        throw new FmtError("OPTION", `SDK ${key} must be boolean`);
+      if (value)
+        append(flag);
+    }
+    if (options.prefix !== void 0) {
+      append("-p");
+      append(options.prefix);
+    }
+    append("--");
+    if (options.files !== void 0) {
+      if (options.files.length > 4096)
+        throw new FmtError("LIMIT", "argument count limit exceeded");
+      for (const file of options.files) {
+        if (typeof file !== "string")
+          throw new FmtError("OPTION", "SDK files must be literal VFS paths");
+        append(file);
+      }
+    }
+  }
+  return args;
+}
+
+// packages/safe-bash-command-fmt/dist/command.js
+var inputRequirements = [
+  { id: "stdin", description: "Read standard input", capabilities: [] },
+  { id: "file", description: "Read file operands", capabilities: [], anyOf: [["streamingRead"], ["read"]] }
+];
+async function yieldTurn(signal) {
+  signal.throwIfAborted();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  signal.throwIfAborted();
+}
+async function output(context, bytes) {
+  await writeBytes(context.stdout, typeof bytes === "string" ? new TextEncoder().encode(bytes) : bytes, context.signal);
+}
+async function diagnostic(context, error) {
+  let message = "internal error";
+  if (error instanceof FmtError || error instanceof FsError || error instanceof CommandArgumentIdentityError)
+    message = error.message;
+  else {
+    try {
+      const pending = context.onInternalError?.(error);
+      if (pending !== void 0)
+        void Promise.resolve(pending).catch(() => void 0);
+    } catch {
+    }
+  }
+  let escaped = "";
+  for (const character of message) {
+    const point = character.codePointAt(0);
+    if (point === 9 || point === 10 || point >= 32 && (point < 127 || point > 159))
+      escaped += character;
+    else
+      for (const byte of new TextEncoder().encode(character))
+        escaped += `\\${byte.toString(8).padStart(3, "0")}`;
+  }
+  await writeBytes(context.stderr, new TextEncoder().encode(`fmt: ${escaped}
+`), context.signal);
+}
+function pathOf(context, path) {
+  if (!path)
+    throw new FsError("ENOENT", { path });
+  validatePath(path);
+  validatePath(context.cwd);
+  if (!isAbsolutePath(context.cwd))
+    throw new FsError("EINVAL", { path: context.cwd, message: "cwd must be absolute" });
+  return isAbsolutePath(path) ? path : `${context.cwd.endsWith("/") ? context.cwd.slice(0, -1) : context.cwd}/${path}`;
+}
+var InputBudget = class {
+  maximum;
+  sourceBufferBytes;
+  used = 0;
+  constructor(maximum, sourceBufferBytes) {
+    this.maximum = maximum;
+    this.sourceBufferBytes = sourceBufferBytes;
+  }
+  get maxReadBytes() {
+    return Math.max(0, Math.min(this.sourceBufferBytes, this.maximum - this.used));
+  }
+  async *read(source, signal) {
+    for await (const chunk of readBytes(source, signal)) {
+      signal.throwIfAborted();
+      const size = byteView(chunk).length;
+      if (size > this.maximum - this.used)
+        throw new FsError("EFBIG", { message: "byte command input limit exceeded" });
+      if (size > this.maxReadBytes)
+        throw new FmtError("LIMIT", "source chunk retention limit exceeded");
+      this.used += size;
+      if (!size)
+        yield byteSpan(chunk, 0, 0);
+      for (let offset = 0; offset < size; offset += 4096)
+        yield byteSpan(chunk, offset, Math.min(4096, size - offset));
+    }
+  }
+};
+var InputScope = class {
+  context;
+  budget;
+  iterator;
+  reader;
+  finished = false;
+  retirement;
+  closing;
+  acquisition;
+  constructor(context, budget) {
+    this.context = context;
+    this.budget = budget;
+  }
+  open(name, bytes) {
+    if (this.closing)
+      throw new FmtError("CLOSED", "fmt input is closed");
+    const { context } = this;
+    context.signal.throwIfAborted();
+    this.acquisition = Promise.resolve().then(async () => {
+      context.signal.throwIfAborted();
+      let file;
+      if (name !== "-") {
+        const encoded = new TextEncoder().encode(name);
+        if (encoded.length !== bytes.length || encoded.some((byte, index) => byte !== bytes[index]))
+          throw new FsError("ENOENT", { path: name });
+        const path = pathOf(context, name);
+        const capabilities = await context.fs.capabilitiesFor?.(path, { signal: context.signal }) ?? context.fs.capabilities;
+        context.signal.throwIfAborted();
+        file = { path, capabilities };
+      }
+      context.signal.throwIfAborted();
+      let source = context.stdin;
+      if (file) {
+        const { path, capabilities } = file;
+        assertCommandRequirements(context, inputRequirements, ["file"], capabilities);
+        if (context.fs.readStream && capabilities.streamingRead !== false)
+          source = context.fs.readStream(path, { signal: context.signal, chunkSize: 4096 });
+        else {
+          if (capabilities.read === false)
+            throw new FsError("ENOTSUP", { path, syscall: "readFile" });
+          const maximum = this.budget.maxReadBytes;
+          source = { async *[Symbol.asyncIterator]() {
+            yield await context.fs.readFile(path, { signal: context.signal, maxBytes: maximum });
+          } };
+        }
+      }
+      context.signal.throwIfAborted();
+      this.iterator = source[Symbol.asyncIterator]();
+      this.reader = this.budget.read({ [Symbol.asyncIterator]: () => ({
+        next: async () => {
+          const item = await this.iterator.next();
+          if (item.done)
+            this.finished = true;
+          return item;
+        },
+        return: async () => {
+          await this.retire();
+          return { done: true, value: void 0 };
+        }
+      }) }, context.signal)[Symbol.asyncIterator]();
+    });
+    return this.acquisition;
+  }
+  async next() {
+    const item = await this.reader.next();
+    return item.done ? null : item.value;
+  }
+  retire() {
+    this.retirement ??= Promise.resolve().then(async () => {
+      if (!this.finished)
+        await this.iterator?.return?.();
+    });
+    return this.retirement;
+  }
+  close() {
+    this.closing ??= (async () => {
+      const results = await Promise.allSettled([this.retire(), this.reader?.return?.()]);
+      for (const result of results)
+        if (result.status === "rejected")
+          throw result.reason;
+    })();
+    return this.closing;
+  }
+};
+function fileError(error, name, bytes, opening, context, releasedRead = false) {
+  if (!(error instanceof FsError))
+    return error;
+  const messages = { ENOENT: "No such file or directory", EACCES: "Permission denied", EISDIR: "Is a directory", ENOTDIR: "Not a directory", ELOOP: "Too many levels of symbolic links", EIO: "Input/output error", EBADF: "Bad file descriptor" };
+  const message = messages[error.code];
+  if (!message)
+    return error;
+  if (releasedRead && !opening)
+    return new FmtError("INPUT", `${name === "-" ? "read error" : `error reading ${quote(bytes, true, unicodeLocale(context))}`}: ${message}`);
+  return new FmtError("INPUT", `${opening ? `cannot open ${quote(bytes, true, unicodeLocale(context))} for reading` : name === "-" ? "standard input" : name}: ${message}`);
+}
+function fmtCommand(configuration = {}) {
+  return { name: "fmt", runtimeIdentity: commandRuntimeIdentity, filesystemRequirements: inputRequirements, execute: (context) => fmt(context, configuration) };
+}
+function fmtCommands(configuration = {}) {
+  const command = fmtCommand(configuration);
+  const replace = configuration.replace ?? false;
+  return { name: "fmt", setup(host) {
+    host.commands.register(command, { replace });
+  } };
+}
+async function fmt(context, configuration = {}) {
+  context.signal.throwIfAborted();
+  const controller = new AbortController();
+  const local = { ...context, signal: AbortSignal.any([context.signal, controller.signal]) };
+  const limits = { ...defaultFmtLimits, ...configuration.limits };
+  let sdkArguments;
+  let argumentFailure;
+  let activeEngine;
+  let stdout;
+  let current;
+  let closing;
+  const close = () => {
+    if (closing)
+      return closing;
+    let resolve, reject;
+    closing = new Promise((complete, fail) => {
+      resolve = complete;
+      reject = fail;
+    });
+    controller.abort(new FsError("EPIPE", { message: "fmt input closed" }));
+    activeEngine?.dispose();
+    void Promise.allSettled([current?.close(), stdout?.close()]).then((results) => {
+      const failures = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+      if (failures.length)
+        reject(failures.length === 1 ? failures[0] : new AggregateError(failures, "fmt cleanup failed"));
+      else
+        resolve();
+    });
+    return closing;
+  };
+  context.registerCleanup?.(close);
+  try {
+    validateFmtLimits(limits);
+    sdkArguments = captureFmtArguments(configuration, limits);
+  } catch (error) {
+    argumentFailure = { error };
+  }
+  let failed = false;
+  const run = async () => {
+    try {
+      if (argumentFailure)
+        throw argumentFailure.error;
+      const argumentsWithBytes = getCommandArguments(context);
+      let extent = 0;
+      if (argumentsWithBytes.values.length > 4096)
+        throw new FmtError("LIMIT", "argument count limit exceeded");
+      const bytes = sdkArguments ?? argumentsWithBytes.values.map((value, index) => {
+        if (typeof value === "string" && value.length > limits.argumentBytes - extent)
+          throw new FmtError("LIMIT", "argument limit exceeded");
+        const size = shellValueByteLength2(value);
+        if (size > limits.argumentBytes - extent)
+          throw new FmtError("LIMIT", "argument limit exceeded");
+        extent += size;
+        return argumentsWithBytes.bytes(index);
+      });
+      const settings = parseFmtArguments(bytes, { limits, ...configuration.profile !== void 0 ? { profile: configuration.profile } : {}, posixlyCorrect: context.env.POSIXLY_CORRECT !== void 0, unicodeQuotes: unicodeLocale(context) });
+      if (settings.information) {
+        await output(context, settings.information === "version" ? "fmt (virtual-bash)\n" : "Usage: fmt [-WIDTH] [OPTION]... [FILE]...\nReformat paragraphs; omitted FILE or '-' reads standard input.\n  -c, --crown-margin       preserve indentation of first two lines\n  -t, --tagged-paragraph   use distinct first and following margins\n  -p, --prefix=STRING      format only lines with this prefix\n  -s, --split-only         split lines without joining\n  -u, --uniform-spacing    one space between words, two after sentences\n  -w, --width=WIDTH        maximum width (default 75)\n  -g, --goal=WIDTH         preferred width (default 93% of width)\n      --help              display this help\n      --version           display virtual command identity\n");
+        return { exitCode: 0 };
+      }
+      const budget = new InputBudget(limits.inputBytes, limits.retainedBytes - 10120 - settings.prefix.length);
+      let work = 0, outputBytes = 0;
+      stdout = createOutputOperation({ signal: local.signal }, context.stdout);
+      const outputContext = { ...context, stdout: stdout.output };
+      let stdinDone = false;
+      let emptyChunks = 0;
+      let chunks = 0;
+      let exitCode = 0;
+      for (const { name, bytes: nameBytes } of settings.files) {
+        local.signal.throwIfAborted();
+        if (name === "-" && stdinDone)
+          continue;
+        current = new InputScope(local, budget);
+        try {
+          await current.open(name, nameBytes);
+        } catch (error) {
+          local.signal.throwIfAborted();
+          await diagnostic(context, fileError(error, name, nameBytes, true, context));
+          await current.close();
+          exitCode = 1;
+          continue;
+        }
+        activeEngine = createFmtEngine(settings, { ...limits, inputBytes: limits.inputBytes, work: limits.work - work, outputBytes: limits.outputBytes - outputBytes }, local.signal);
+        const machine = activeEngine.run();
+        let step = machine.next();
+        let readFailed = false;
+        let readError;
+        let received = false;
+        while (!step.done) {
+          local.signal.throwIfAborted();
+          if (step.value === "input") {
+            let bytes2 = null;
+            if (!readFailed) {
+              try {
+                bytes2 = await current.next();
+                if (bytes2?.length)
+                  received = true;
+              } catch (error) {
+                local.signal.throwIfAborted();
+                if (isFsError(error, "EFBIG"))
+                  throw new FmtError("LIMIT", "byte command input limit exceeded");
+                readFailed = true;
+                readError = !received && name !== "-" && error instanceof FsError && ["ENOENT", "EACCES", "ENOTDIR", "ELOOP"].includes(error.code) ? fileError(error, name, nameBytes, true, context) : error;
+              }
+            }
+            if (bytes2?.length === 0 && ++emptyChunks > 4096)
+              throw new FmtError("LIMIT", "empty input chunk limit exceeded");
+            if (++chunks % 64 === 0)
+              await yieldTurn(local.signal);
+            step = machine.next(bytes2);
+          } else {
+            if (step.value)
+              await output(outputContext, step.value);
+            else
+              await yieldTurn(local.signal);
+            step = machine.next();
+          }
+        }
+        try {
+          await current.close();
+        } catch (error) {
+          if (!readFailed)
+            throw error;
+        }
+        current = void 0;
+        work += activeEngine.accounting().work;
+        outputBytes += activeEngine.accounting().outputBytes;
+        activeEngine.dispose();
+        activeEngine = void 0;
+        if (name === "-")
+          stdinDone = true;
+        if (readFailed && (settings.profile !== "gnu-coreutils-8.30-C-bytes" || !isFsError(readError, "EISDIR") && !isFsError(readError, "EIO") && !isFsError(readError, "EBADF"))) {
+          await diagnostic(context, fileError(readError, name, nameBytes, false, context, settings.profile !== "gnu-coreutils-8.30-C-bytes"));
+          exitCode = 1;
+        }
+      }
+      return { exitCode };
+    } catch (error) {
+      failed = true;
+      context.signal.throwIfAborted();
+      if (error instanceof FmtError && error.usage)
+        await writeBytes(context.stderr, Uint8Array.from(`fmt: ${error.message}
+Try 'fmt --help' for more information.
+`, (character) => character.charCodeAt(0)), context.signal);
+      else
+        await diagnostic(context, error);
+      return { exitCode: 1 };
+    }
+  };
+  let outcome;
+  try {
+    outcome = { result: await run() };
+  } catch (error) {
+    outcome = { error };
+  }
+  try {
+    await close();
+  } catch (error) {
+    if (!failed)
+      throw error;
+  }
+  if ("error" in outcome)
+    throw outcome.error;
+  return outcome.result;
+}
+export {
+  FmtError,
+  createFmtEngine,
+  defaultFmtLimits,
+  fmt,
+  fmtBaseline,
+  fmtCommand,
+  fmtCommands,
+  parseFmtArguments
+};
+//# sourceMappingURL=index.js.map