@ai-ecoverse/slicc-kernel 1.133.5 → 1.134.0

package/README.md

@@ -504,7 +504,13 @@ The module's default export (or its `main` export) is called with a context and
         - `AUTH PLAIN <blob>`, or the line after a bare `AUTH PLAIN`: the kernel decodes the blob, and asks the vault (`auth-plain`) only when the placeholders are in the **password field**. A placeholder in the user or authorization identity goes out as written. It substitutes there and re-encodes.
         - `AUTH LOGIN`: the password line (the second line, or the first after `AUTH LOGIN <user>`) is decoded, substituted (`auth-login`) and re-encoded; the user line goes out as written.
         - Every other line goes out as written. After the first `AUTH`, or once `MAIL`, `RCPT`, `DATA` or `BDAT` is seen, so is the rest of the session. A line still unfinished after 2 s, or longer than 4 KiB, is sent as written, and so is the rest.
-      - **pg:** a session that starts with a protocol 3 `StartupMessage` (after `sslmode`'s `SSLRequest` upgrade, or with direct TLS) is followed message by message. The only position is the **`PasswordMessage` answering `AuthenticationCleartextPassword` (`R` 3)**, as the program read it from the server. The password is substituted (`password-cleartext`) and the message is framed again. Anything else goes out as written: the startup, an MD5 (`R` 5) or SCRAM (`R` 10) answer, every later message, and a frame over 16 KiB. MD5 and SCRAM need the kernel to compute the answer from the password, so they aren't supported yet. A server whose `pg_hba` asks for them gets the placeholder, and refuses.
+      - **pg:** a session that starts with a protocol 3 `StartupMessage` (after `sslmode`'s `SSLRequest` upgrade, or with direct TLS) is followed message by message. The only position is the **`PasswordMessage` answering `AuthenticationCleartextPassword` (`R` 3)**, as the program read it from the server. The password is substituted (`password-cleartext`) and the message is framed again. **SCRAM-SHA-256** (`R` 10, the pg 14+ default) works with an unmodified client:
+        - **What the server is offered:** in a session that can substitute, the kernel offers the program only `SCRAM-SHA-256`, never `-PLUS`. The program's client computes its proof from the placeholder. Dropping `-PLUS` costs nothing here: the kernel terminates and verifies the TLS itself, so channel binding would only bind to the kernel's own session. A client that **requires** channel binding (libpq's `channel_binding=require`) refuses the connection and never gets the value, so leave it at `prefer` or `disable` for sealed SCRAM.
+        - **The match:** the kernel sends the three SCRAM messages and that proof to the vault (`scram-sha-256`, with no placeholders), and the vault names the one bound placeholder whose proof matches.
+        - **The exchange:** the kernel recomputes the proof from the value and sends that instead. It checks the server's final signature against the value **before** it hands the program the signature its own placeholder-based check expects. A server whose signature doesn't verify, or that answers with an error, ends the session (`EPROTO`) without passing it on. The salted password and the derived keys are wiped after the exchange.
+        - **Requirements:** only the plain GS2 header (`n,,`) and the bare RFC 5802 messages; at most 100000 iterations.
+
+        Anything else goes out as written: the startup, an MD5 (`R` 5) answer, every later message, and a frame over 16 KiB. A server whose `pg_hba` asks for MD5 gets the placeholder, and refuses.
       - **What goes out:** the placeholders the vault answers with a value of at least 8 bytes go out as that value (`Basic` decoded, substituted and re-encoded). Everything else goes out as written:
         - the request line and the body;
         - other headers;

package/dist/kernel-worker.js

@@ -7095,7 +7095,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.133.5" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.134.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -14158,8 +14158,8 @@ var EventFd = class _EventFd {
   count;
   semaphore;
   changes = new Notifier();
-  constructor(initial, semaphore) {
-    this.count = initial;
+  constructor(initial2, semaphore) {
+    this.count = initial2;
     this.semaphore = semaphore;
   }
   async read(max, signal) {
@@ -17908,7 +17908,7 @@ var UNSAFE = /[\r\n\0]/;
 var POSITIONS = {
   http1: (position) => HEADER.test(position),
   smtp: (position) => position === "auth-plain" || position === "auth-login",
-  pg: (position) => position === "password-cleartext"
+  pg: (position) => position === "password-cleartext" || position === "scram-sha-256"
 };
 function boundHost(servername) {
   const lower = servername.toLowerCase();
@@ -17923,6 +17923,15 @@ function placeholdersOk(list) {
   if (!Array.isArray(list) || list.length === 0 || list.length > SESSION_PLACEHOLDERS) return false;
   return new Set(list).size === list.length && list.every((p) => typeof p === "string" && SESSION_PLACEHOLDER.test(p));
 }
+var SCRAM_TEXT = /^[\x21-\x7e]{1,1024}$/;
+function scramOk(f) {
+  if (f.position !== "scram-sha-256")
+    return f.scram === void 0 && placeholdersOk(f.placeholders);
+  const x = f.scram;
+  if (f.placeholders !== void 0 || typeof x !== "object" || x === null) return false;
+  const texts = [x.clientFirstBare, x.serverFirst, x.clientFinalBare, x.proof];
+  return texts.every((t) => typeof t === "string" && SCRAM_TEXT.test(t));
+}
 function hostOk(host) {
   return typeof host === "string" && HOST.test(host) && boundHost(host) === host;
 }
@@ -17934,7 +17943,7 @@ function sessionAskable(f, now) {
   if (!Number.isInteger(f.port) || f.port < 1 || f.port > 65535) return false;
   const age = now - f.handshakeAt;
   if (!Number.isFinite(age) || age < 0 || age > SESSION_WINDOW_MS) return false;
-  return typeof f.exit === "string" && SESSION_EXIT.test(f.exit) && placeholdersOk(f.placeholders) && headOk(f);
+  return typeof f.exit === "string" && SESSION_EXIT.test(f.exit) && scramOk(f) && headOk(f);
 }
 function sessionRequest(f) {
   return {
@@ -17950,8 +17959,16 @@ function sessionRequest(f) {
     verified: true,
     handshakeAt: f.handshakeAt,
     exit: f.exit,
-    placeholders: [...f.placeholders],
-    ...f.head ? { head: { method: f.head.method, path: f.head.path } } : {}
+    ...f.placeholders ? { placeholders: [...f.placeholders] } : {},
+    ...f.head ? { head: { method: f.head.method, path: f.head.path } } : {},
+    ...f.scram ? {
+      scram: {
+        clientFirstBare: f.scram.clientFirstBare,
+        serverFirst: f.scram.serverFirst,
+        clientFinalBare: f.scram.clientFinalBare,
+        proof: f.scram.proof
+      }
+    } : {}
   };
 }
 function sessionValues(reply, asked) {
@@ -17959,7 +17976,9 @@ function sessionValues(reply, asked) {
   const { error, values } = reply;
   if (error !== void 0 || typeof values !== "object" || values === null) return void 0;
   const out = {};
-  for (const ph of asked) {
+  const keys = Object.keys(values);
+  const wanted = asked ?? (keys.length === 1 && SESSION_PLACEHOLDER.test(keys[0]) ? keys : []);
+  for (const ph of wanted) {
     const value2 = values[ph];
     if (typeof value2 === "string" && value2.length > 0 && !UNSAFE.test(value2)) out[ph] = value2;
   }
@@ -18651,6 +18670,104 @@ async function substituteHead(head, ask) {
 `, values };
 }
 
+// src/kernel/net/sealed-scram.ts
+var encoder8 = new TextEncoder();
+function base64Bytes(text) {
+  try {
+    return Uint8Array.from(atob(text), (c) => c.charCodeAt(0));
+  } catch {
+    return void 0;
+  }
+}
+function base64Of(bytes) {
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  return btoa(bin);
+}
+function clientFirstBare(message3) {
+  const m = /^n,,(n=[^,]*,r=[^,]+)$/.exec(message3);
+  return m ? m[1] : void 0;
+}
+var SERVER_FIRST = /^r=([^,]+),s=([^,]+),i=(\d{1,6})$/;
+var CLIENT_FINAL = /^(c=biws,r=([^,]+)),p=([^,]+)$/;
+var SCRAM_MAX = 1024;
+function exchangeOf(clientFirst, serverFirst, clientFinal) {
+  const bare = clientFirstBare(clientFirst);
+  const sf = SERVER_FIRST.exec(serverFirst);
+  const fin = CLIENT_FINAL.exec(clientFinal);
+  if (!bare || !sf || !fin || [bare, serverFirst, clientFinal].some((t) => t.length > SCRAM_MAX))
+    return void 0;
+  const cnonce = bare.slice(bare.indexOf(",r=") + 3);
+  const nonce = sf[1];
+  const salt = base64Bytes(sf[2]);
+  const iterations = Number(sf[3]);
+  const proof = base64Bytes(fin[3]);
+  const ok4 = fin[2] === nonce && nonce.startsWith(cnonce) && iterations >= 1 && iterations <= 1e5 && salt !== void 0 && proof?.length === 32;
+  if (!ok4) return void 0;
+  return {
+    exchange: {
+      clientFirstBare: bare,
+      serverFirst,
+      clientFinalBare: fin[1],
+      salt,
+      iterations
+    },
+    proof
+  };
+}
+async function hmac(key, data) {
+  const k = await crypto.subtle.importKey(
+    "raw",
+    key,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  return new Uint8Array(await crypto.subtle.sign("HMAC", k, data));
+}
+async function scramKeys(password, x) {
+  const base = await crypto.subtle.importKey("raw", encoder8.encode(password), "PBKDF2", false, [
+    "deriveBits"
+  ]);
+  const salted = new Uint8Array(
+    await crypto.subtle.deriveBits(
+      {
+        name: "PBKDF2",
+        hash: "SHA-256",
+        salt: x.salt,
+        iterations: x.iterations
+      },
+      base,
+      256
+    )
+  );
+  const clientKey = await hmac(salted, encoder8.encode("Client Key"));
+  const stored = new Uint8Array(
+    await crypto.subtle.digest("SHA-256", clientKey)
+  );
+  const auth = encoder8.encode(`${x.clientFirstBare},${x.serverFirst},${x.clientFinalBare}`);
+  const signature = await hmac(stored, auth);
+  const proof = clientKey.map((b, i) => b ^ signature[i]);
+  const serverKey = await hmac(salted, encoder8.encode("Server Key"));
+  const serverSignature = await hmac(serverKey, auth);
+  for (const k of [salted, clientKey, stored, signature, serverKey]) k.fill(0);
+  return { proof, serverSignature };
+}
+var SPACES = /[\u00A0\u1680\u2000-\u200B\u202F\u205F\u3000]/g;
+var NOTHING2 = /\u00AD|\u034F|\u1806|[\u180B-\u180D]|\u200C|\u200D|\u2060|[\uFE00-\uFE0F]|\uFEFF/g;
+var PROHIBITED = /[\u0000-\u001F\u007F-\u009F\uE000-\uF8FF\uFFFE\uFFFF]/;
+function saslprep(password) {
+  if (/^[\x20-\x7e]*$/.test(password)) return password;
+  const mapped = password.replace(SPACES, " ").replace(NOTHING2, "").normalize("NFKC");
+  return PROHIBITED.test(mapped) ? password : mapped;
+}
+function sameBytes(a, b) {
+  if (a.length !== b.length) return false;
+  let d = 0;
+  for (let i = 0; i < a.length; i++) d |= a[i] ^ b[i];
+  return d === 0;
+}
+
 // src/kernel/net/sealed-pg.ts
 var PG_MESSAGE_MAX = 16 * 1024;
 var PROTOCOL_3 = 196608;
@@ -18665,44 +18782,101 @@ function sniffPg(start2) {
   const length2 = int32(bytes, 0);
   return length2 >= 8 && length2 <= PG_MESSAGE_MAX && int32(bytes, 4) === PROTOCOL_3 ? "yes" : "no";
 }
+var PLUS = "SCRAM-SHA-256-PLUS";
+var SASL = 10;
+var SASL_CONTINUE = 11;
+var SASL_FINAL = 12;
+function latin(bytes) {
+  let out = "";
+  for (const b of bytes) out += String.fromCharCode(b);
+  return out;
+}
 var PgServer = class {
   buffer = new Uint8Array(0);
   skip = 0;
-  lost = false;
   cleartext = false;
-  feed(bytes) {
-    if (this.lost) return;
+  sasl = false;
+  serverFirst;
+  expect;
+  failed = false;
+  lost = false;
+  auth(message3) {
+    const code = message3.length >= 9 ? int32(message3, 5) : -1;
+    if (this.expect && code !== SASL_FINAL) this.failed = true;
+    this.cleartext = message3.length === 9 && code === CLEARTEXT;
+    if (code === SASL) return this.mechanisms(message3);
+    else if (code === SASL_CONTINUE) this.serverFirst = latin(message3.subarray(9));
+    else if (code === SASL_FINAL) this.final(message3);
+    return message3;
+  }
+  mechanisms(message3) {
+    this.sasl = true;
+    const names2 = latin(message3.subarray(9)).split("\0").filter((n) => n !== "" && n !== PLUS);
+    return frame3(82, `${latin(message3.subarray(5, 9))}${names2.map((n) => `${n}\0`).join("")}\0`);
+  }
+  final(message3) {
+    const expect = this.expect;
+    if (!expect) return;
+    this.expect = void 0;
+    const data = latin(message3.subarray(9));
+    if (data !== expect.real || expect.fake.length !== expect.real.length) {
+      this.failed = true;
+      return;
+    }
+    for (let i = 0; i < expect.fake.length; i++) message3[9 + i] = expect.fake.charCodeAt(i);
+  }
+  lose() {
+    this.lost = true;
+    this.cleartext = false;
+    this.sasl = false;
+    if (this.expect) this.failed = true;
+    this.expect = void 0;
+  }
+  filter(bytes) {
+    if (this.lost) return bytes;
     const data = new Uint8Array(this.buffer.length + bytes.length);
     data.set(this.buffer);
     data.set(bytes, this.buffer.length);
+    const out = [];
     let at = 0;
     for (; ; ) {
       const left = data.length - at;
       if (this.skip > 0) {
         const n = Math.min(this.skip, left);
+        out.push(data.subarray(at, at + n));
         this.skip -= n;
         at += n;
         if (this.skip > 0) break;
         continue;
       }
       if (left < 5) break;
-      const type = data[at];
       const whole = 1 + int32(data, at + 1);
-      if (whole < 5 || type === 82 && whole > PG_MESSAGE_MAX) {
-        this.lost = true;
-        this.cleartext = false;
-        this.buffer = new Uint8Array(0);
-        return;
+      if (whole < 5 || data[at] === 82 && whole > PG_MESSAGE_MAX) {
+        this.lose();
+        out.push(data.subarray(at));
+        at = data.length;
+        break;
       }
-      if (type !== 82) {
+      if (data[at] !== 82) {
+        if (this.expect) {
+          this.failed = true;
+          break;
+        }
         this.skip = whole;
         continue;
       }
       if (left < whole) break;
-      this.cleartext = whole === 9 && int32(data, at + 5) === CLEARTEXT;
+      out.push(this.auth(data.slice(at, at + whole)));
       at += whole;
     }
     this.buffer = data.slice(at);
+    const joined4 = new Uint8Array(out.reduce((n, b) => n + b.length, 0));
+    let to = 0;
+    for (const b of out) {
+      joined4.set(b, to);
+      to += b.length;
+    }
+    return joined4;
   }
 };
 function frame3(type, body) {
@@ -18719,21 +18893,76 @@ function pgLength(bytes, started) {
   const length2 = int32(bytes, started ? 1 : 0);
   return started ? 1 + length2 : length2;
 }
-async function pgPassword(message3, server, ask) {
-  if (message3[0] !== 112 || !server.cleartext) return { bytes: message3, done: true };
-  server.cleartext = false;
-  let body = "";
-  for (const b of message3.subarray(5)) body += String.fromCharCode(b);
+var MECHANISMS = /* @__PURE__ */ new Set(["SCRAM-SHA-256"]);
+async function cleartext(message3, asks) {
+  const body = latin(message3.subarray(5));
   if (!body.endsWith("\0") || body.indexOf("\0") !== body.length - 1)
     return { bytes: message3, done: true };
   const password = body.slice(0, -1);
   const placeholders = placeholdersIn(password);
   if (placeholders.length === 0 || placeholders.length > SESSION_PLACEHOLDERS)
     return { bytes: message3, done: true };
-  const values = usable(await ask(placeholders));
+  const values = usable(await asks.cleartext(placeholders));
   if (Object.keys(values).length === 0) return { bytes: message3, done: true };
   return { bytes: frame3(112, `${replaced(password, values)}\0`), values, done: true };
 }
+function initial(message3) {
+  const body = latin(message3.subarray(5));
+  const nul = body.indexOf("\0");
+  if (nul < 0 || !MECHANISMS.has(body.slice(0, nul)) || body.length < nul + 5) return void 0;
+  const data = message3.subarray(5 + nul + 5);
+  return int32(message3, 5 + nul + 1) === data.length ? latin(data) : void 0;
+}
+var PgClient = class {
+  clientFirst;
+  server;
+  asks;
+  constructor(server, asks) {
+    this.server = server;
+    this.asks = asks;
+  }
+  async message(message3) {
+    const server = this.server;
+    if (message3[0] !== 112) return { bytes: message3, done: true };
+    if (server.cleartext) {
+      server.cleartext = false;
+      return cleartext(message3, this.asks);
+    }
+    if (server.sasl && this.clientFirst === void 0) {
+      this.clientFirst = initial(message3);
+      return { bytes: message3, done: this.clientFirst === void 0 };
+    }
+    if (this.clientFirst !== void 0 && server.serverFirst !== void 0)
+      return this.final(message3, this.clientFirst, server.serverFirst);
+    return { bytes: message3, done: true };
+  }
+  async final(message3, first, serverFirst) {
+    const got = exchangeOf(first, serverFirst, latin(message3.subarray(5)));
+    if (!got) return { bytes: message3, done: true };
+    const x = got.exchange;
+    const values = usable(
+      await this.asks.scram({
+        clientFirstBare: x.clientFirstBare,
+        serverFirst: x.serverFirst,
+        clientFinalBare: x.clientFinalBare,
+        proof: base64Of(got.proof)
+      })
+    );
+    const [entry, ...more] = Object.entries(values);
+    if (!entry || more.length > 0) return { bytes: message3, done: true };
+    const [placeholder, value2] = entry;
+    const fake = await scramKeys(placeholder, x);
+    if (!sameBytes(fake.proof, got.proof)) return { bytes: message3, done: true };
+    const real = await scramKeys(saslprep(value2), x);
+    this.server.expect = {
+      real: `v=${base64Of(real.serverSignature)}`,
+      fake: `v=${base64Of(fake.serverSignature)}`
+    };
+    const bytes = frame3(112, `${x.clientFinalBare},p=${base64Of(real.proof)}`);
+    for (const k of [real.proof, real.serverSignature, fake.proof, fake.serverSignature]) k.fill(0);
+    return { bytes, values, done: true };
+  }
+};
 
 // src/kernel/net/sealed-smtp.ts
 var SMTP_LINE_MAX = 4096;
@@ -18878,17 +19107,21 @@ var SessionWriter = class {
   session = sessionId();
   smtp;
   pgStarted = false;
+  sawPg = false;
   conn;
   s;
-  pg;
+  pgClient;
   scope;
   constructor(conn, s, pg, scope) {
     this.conn = conn;
     this.s = s;
-    this.pg = pg;
     this.scope = scope;
+    this.pgClient = new PgClient(pg, {
+      cleartext: (placeholders) => this.ask("pg", "password-cleartext", { placeholders }),
+      scram: (scram) => this.ask("pg", "scram-sha-256", { scram })
+    });
     this.smtp = new SmtpClient(
-      (position, placeholders) => this.ask("smtp", position, placeholders)
+      (position, placeholders) => this.ask("smtp", position, { placeholders })
     );
   }
   write(bytes) {
@@ -18899,7 +19132,7 @@ var SessionWriter = class {
     );
     return run2;
   }
-  async ask(protocol, position, placeholders, head) {
+  async ask(protocol, position, extra) {
     const s = this.s;
     const values = await s.broker.sessionMaterialize({
       stamp: await s.stamp(),
@@ -18911,8 +19144,7 @@ var SessionWriter = class {
       verified: s.verified,
       handshakeAt: s.handshakeAt,
       exit: s.exit,
-      placeholders,
-      ...head ? { head } : {}
+      ...extra
     });
     return values;
   }
@@ -18931,6 +19163,7 @@ var SessionWriter = class {
     this.buffer.fill(0);
     this.buffer = joined4;
     if (this.mode === "sniff") this.mode = modeOf(latin12(joined4.subarray(0, 8))) ?? "sniff";
+    if (this.mode === "pg") this.sawPg = true;
     if (this.mode === "pass") await this.release();
     else if (this.mode === "http1") await this.http1();
     else if (this.mode === "smtp") await this.lines();
@@ -18977,11 +19210,7 @@ var SessionWriter = class {
       this.buffer = this.buffer.slice(whole);
       const started = this.pgStarted;
       this.pgStarted = true;
-      const out = started ? await pgPassword(
-        message3,
-        this.pg,
-        (placeholders) => this.ask("pg", "password-cleartext", placeholders)
-      ).catch(() => ({ bytes: message3, done: true })) : { bytes: message3, done: false };
+      const out = started ? await this.pgClient.message(message3).catch(() => ({ bytes: message3, done: true })) : { bytes: message3, done: false };
       if ("values" in out && out.values) this.remember(out.values);
       try {
         await writeAll4(this.conn, out.bytes);
@@ -19013,7 +19242,7 @@ var SessionWriter = class {
     this.buffer = new Uint8Array(0);
     const done5 = await substituteHead(
       latin12(all.subarray(0, end)),
-      (position, placeholders, head2) => this.ask("http1", position, placeholders, head2)
+      (position, placeholders, head2) => this.ask("http1", position, { placeholders, head: head2 })
     ).catch(() => void 0);
     const head = done5 ? bytesOf(done5.head) : all.subarray(0, end);
     if (done5) this.remember(done5.values);
@@ -19111,9 +19340,19 @@ function sealedConn(conn, s) {
   const observed = {
     ...conn,
     read: async () => {
-      const bytes = await conn.read();
-      if (bytes) pg.feed(bytes);
-      return bytes;
+      for (; ; ) {
+        const bytes = await conn.read();
+        if (!bytes) return bytes;
+        const out = writer?.sawPg ? pg.filter(bytes) : bytes;
+        if (pg.failed) {
+          conn.close();
+          throw new KernelError(
+            "EPROTO",
+            "ERR_SSL_PROTOCOL_ERROR: the pg server failed the SCRAM proof"
+          );
+        }
+        if (out.length > 0) return out;
+      }
     }
   };
   const reader = new ScrubReader(writer ? observed : conn, scope);
@@ -24193,7 +24432,7 @@ var SEALED_OPS = /* @__PURE__ */ new Set([
   "cancel",
   "materialize"
 ]);
-var encoder8 = new TextEncoder();
+var encoder9 = new TextEncoder();
 var decoder3 = new TextDecoder("utf-8", { fatal: true });
 function parseSealed(bytes) {
   try {
@@ -24274,7 +24513,7 @@ var SealedChannel = class {
         await this.broker.tickets.record(req, reply, caller.pid);
       if (this.inflight !== flight) return;
       this.inflight = void 0;
-      if (reply) this.reply = encoder8.encode(serialized(reply));
+      if (reply) this.reply = encoder9.encode(serialized(reply));
     });
     this.inflight = flight;
     return length2;
@@ -26010,9 +26249,9 @@ function importedMemory(bytes) {
   };
   const limits = () => {
     const flags2 = bytes[at++];
-    const initial = u32();
+    const initial2 = u32();
     const maximum = flags2 & 1 ? u32() : void 0;
-    return { initial, maximum, shared: (flags2 & 2) !== 0 };
+    return { initial: initial2, maximum, shared: (flags2 & 2) !== 0 };
   };
   while (at < bytes.length) {
     const id2 = bytes[at++];
@@ -26657,7 +26896,7 @@ var LAYOUT = [
 var IN_TREE = /* @__PURE__ */ new Set([SUDO_PATH, CRONTAB_PATH]);
 var LOAD_SAMPLE_MS = 5e3;
 var LOAD_WINDOWS_MS = [6e4, 3e5, 9e5];
-var encoder9 = new TextEncoder();
+var encoder10 = new TextEncoder();
 var USERS_MODES = ["off", "report", "enforce"];
 function usersMode(mode = "off") {
   if (USERS_MODES.includes(mode)) return mode;
@@ -28932,7 +29171,7 @@ var Launcher = class {
       },
       account
     );
-    const report = (message3) => options.onData(encoder9.encode(`${message3}\r
+    const report = (message3) => options.onData(encoder10.encode(`${message3}\r
 `));
     const handle = await this.launch(planned, {
       env,
@@ -28970,7 +29209,7 @@ var Launcher = class {
     };
     const stdout = collect(out, options.onStdout);
     const stderr = collect(err, options.onStderr);
-    const report = (message3) => stderr(encoder9.encode(`${message3}
+    const report = (message3) => stderr(encoder10.encode(`${message3}
 `));
     if (!planned) {
       const directory = await this.directory(file, this.fs.resolvePath(cwd, file));