@llblab/pi-kit 0.38.3 → 0.39.0

package/node_modules/@llblab/pi-codex-usage/lib/query.ts

@@ -1,16 +1,31 @@
-/** Domain: quota transport. Owns: Pi auth, Codex app-server fallback and errors. Excludes: shared leadership and UI. */
+/** Domain: quota transport. Owns: Pi/Codex auth candidates, guarded HTTP/RPC quota requests and errors. Excludes: shared leadership and UI. */
 import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { join } from "node:path";
 import { createInterface } from "node:readline";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { assertObject, errorMessage, isOpenAICodexModel, normalizeAppServerResponse, normalizeBackendPayload, parseJsonObject, selectUsageSnapshot, type AppServerRateLimitResponse, type CodexUsageModel, type CodexUsageReport, type RateLimitStatusPayload, type UsageQueryError } from "./usage.ts";
+import { assertObject, errorMessage, isOpenAICodexModel, normalizeAppServerResponse, normalizeBackendPayload, parseJsonObject, selectUsageSnapshot, type AppServerRateLimitResponse, type CodexUsageModel, type CodexUsageReport, type RateLimitStatusPayload, type UsageQueryError, type UsageSource } from "./usage.ts";
 const CODEX_USAGE_LIMIT_ID = "codex";
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const CODEX_USAGE_ACCOUNT_HEADER = "ChatGPT-Account-Id";
+const OPENAI_AUTH_CLAIM = "https://api.openai.com/auth";
+const LEGACY_PROVIDER = "openai-codex";
+const NEW_PROVIDER = "openai";
+const USER_AGENT = "pi-codex-usage";
+const TOKEN_EXPIRY_MARGIN_MS = 60_000;
 const MAX_ERROR_BODY_CHARS = 600;
 type PiModel = NonNullable<ExtensionContext["model"]>;
 type QueryUsageOptions = { timeoutMs: number };
 export type QueryUsageResult = { ok: true; report: CodexUsageReport } | { ok: false; errors: UsageQueryError[] };
+type QuotaAuthCandidate = {
+  source: UsageSource;
+  headers: Record<string, string>;
+};
+type QuotaAuthResolution = {
+  candidates: QuotaAuthCandidate[];
+  errors: UsageQueryError[];
+};
 type RpcResponse = {
   id?: unknown;
   result?: unknown;
@@ -29,15 +44,15 @@ export async function queryUsage(
   mayQuery: () => boolean,
 ): Promise<QueryUsageResult | undefined> {
   const errors: UsageQueryError[] = [];
-  const sources = ["pi-auth", "codex-app-server"] as const;
+  if (!mayQuery()) return undefined;
+  const auth = await resolveQuotaAuthCandidates(ctx);
+  errors.push(...auth.errors);
+  if (!mayQuery()) return undefined;
 
-  for (const source of sources) {
+  for (const candidate of auth.candidates) {
     if (!mayQuery()) return undefined;
     try {
-      const report =
-        source === "pi-auth"
-          ? await queryViaPiAuth(ctx, options.timeoutMs, mayQuery)
-          : await queryViaCodexAppServer(options.timeoutMs, mayQuery);
+      const report = await queryViaQuotaAuth(candidate, options.timeoutMs, mayQuery);
       if (!report) return undefined;
       if (
         selectUsageSnapshot(report, CODEX_USAGE_LIMIT_ID) ||
@@ -46,33 +61,44 @@ export async function queryUsage(
         return { ok: true, report };
       }
       errors.push({
-        source,
-        message: `${source} returned no displayable codex rate-limit windows`,
+        source: candidate.source,
+        message: `${candidate.source} returned no displayable rate-limit windows`,
       });
     } catch (cause) {
-      errors.push({ source, message: errorMessage(cause), cause });
+      errors.push({ source: candidate.source, message: errorMessage(cause), cause });
     }
   }
 
+  if (!mayQuery()) return undefined;
+  try {
+    const report = await queryViaCodexAppServer(options.timeoutMs, mayQuery);
+    if (!report) return undefined;
+    if (
+      selectUsageSnapshot(report, CODEX_USAGE_LIMIT_ID) ||
+      report.credits
+    ) {
+      return { ok: true, report };
+    }
+    errors.push({
+      source: "codex-app-server",
+      message: "codex-app-server returned no displayable rate-limit windows",
+    });
+  } catch (cause) {
+    errors.push({ source: "codex-app-server", message: errorMessage(cause), cause });
+  }
+
   return { ok: false, errors };
 }
 
-async function queryViaPiAuth(
-  ctx: ExtensionContext,
+async function queryViaQuotaAuth(
+  candidate: QuotaAuthCandidate,
   timeoutMs: number,
   mayQuery: () => boolean,
 ): Promise<CodexUsageReport | undefined> {
-  const auth = await resolvePiCodexAuth(ctx);
-  if (!auth) {
-    throw new Error(
-      "No Pi OpenAI Codex subscription auth was available. Use an openai or openai-codex subscription model or run /login for OpenAI ChatGPT.",
-    );
-  }
-
   if (!mayQuery()) return undefined;
   const response = await fetchWithTimeout(
     CODEX_USAGE_URL,
-    { headers: auth.headers },
+    { headers: candidate.headers },
     timeoutMs,
   );
   const text = await response.text();
@@ -86,43 +112,93 @@ async function queryViaPiAuth(
   return normalizeBackendPayload(
     payload as RateLimitStatusPayload,
     Date.now(),
-    "pi-auth",
+    candidate.source,
   );
 }
 
-async function resolvePiCodexAuth(
-  ctx: ExtensionContext,
-): Promise<{ headers: Record<string, string> } | undefined> {
-  const models = codexAuthCandidateModels(ctx);
-  const errors: string[] = [];
+// --- Auth Candidates ---
 
-  for (const model of models) {
-    if (model.provider === "openai" && !ctx.modelRegistry.isUsingOAuth(model)) continue;
-    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+export async function resolveQuotaAuthCandidates(
+  ctx: ExtensionContext,
+  env: NodeJS.ProcessEnv = process.env,
+  now = Date.now(),
+): Promise<QuotaAuthResolution> {
+  const candidates: QuotaAuthCandidate[] = [];
+  const errors: UsageQueryError[] = [];
+  const seenTokens = new Set<string>();
+
+  for (const model of orderedCodexAuthModels(ctx)) {
+    if (model.provider === NEW_PROVIDER && !ctx.modelRegistry.isUsingOAuth(model)) continue;
+    const source: UsageSource = model.provider === NEW_PROVIDER
+      ? "pi-auth-openai"
+      : "pi-auth-openai-codex";
+    let auth;
+    try {
+      auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    } catch (cause) {
+      errors.push({ source, message: errorMessage(cause) });
+      continue;
+    }
     if (!auth.ok) {
-      errors.push(auth.error);
+      errors.push({ source, message: auth.error });
       continue;
     }
 
-    const headers: Record<string, string> = {};
-    for (const [name, value] of Object.entries(auth.headers ?? {})) {
-      if (value !== null) headers[name] = value;
-    }
-    if (!hasHeader(headers, "Authorization") && auth.apiKey) {
+    const headers = stringHeaders(auth.headers);
+    if (!hasHeader(headers, "Authorization") && auth.apiKey)
       headers.Authorization = `Bearer ${auth.apiKey}`;
+    const token = bearerToken(headers);
+    if (!token || token.startsWith("sk-")) continue;
+    const accountId = headerValue(headers, CODEX_USAGE_ACCOUNT_HEADER) ?? chatgptAccountId(token);
+    if (model.provider === NEW_PROVIDER && !accountId) {
+      errors.push({
+        source,
+        message: "New Pi OpenAI OAuth credential is not accepted by the Codex usage endpoint",
+      });
+      continue;
     }
-    if (!hasHeader(headers, "User-Agent")) {
-      headers["User-Agent"] = "pi-codex-usage";
+    if (isExpiredToken(token, now)) {
+      errors.push({ source, message: "Pi OpenAI subscription token has expired" });
+      continue;
     }
-    if (hasHeader(headers, "Authorization")) {
-      return { headers };
+    if (accountId && !hasHeader(headers, CODEX_USAGE_ACCOUNT_HEADER))
+      headers[CODEX_USAGE_ACCOUNT_HEADER] = accountId;
+    if (!hasHeader(headers, "User-Agent")) headers["User-Agent"] = USER_AGENT;
+    if (!hasHeader(headers, "Accept")) headers.Accept = "application/json";
+    if (seenTokens.has(token)) continue;
+    seenTokens.add(token);
+    candidates.push({ source, headers });
+  }
+
+  const codexCli = readCodexCliAuth(env, now);
+  if (codexCli) {
+    const token = bearerToken(codexCli.headers);
+    if (token && !seenTokens.has(token)) {
+      seenTokens.add(token);
+      candidates.push(codexCli);
     }
+  } else {
+    errors.push({
+      source: "codex-cli-auth",
+      message: "No usable Codex CLI ChatGPT auth was available",
+    });
   }
 
-  if (errors.length > 0) {
-    throw new Error(errors.join("; "));
+  if (candidates.length === 0 && errors.length === 0) {
+    errors.push({
+      source: "pi-auth",
+      message: "No Pi OpenAI Codex subscription auth was available. Use an openai or openai-codex subscription model or run /login for OpenAI ChatGPT.",
+    });
   }
-  return undefined;
+  return { candidates, errors };
+}
+
+function orderedCodexAuthModels(ctx: ExtensionContext): PiModel[] {
+  const models = codexAuthCandidateModels(ctx);
+  return [
+    ...models.filter((model) => model.provider === LEGACY_PROVIDER),
+    ...models.filter((model) => model.provider === NEW_PROVIDER),
+  ];
 }
 
 function codexAuthCandidateModels(ctx: ExtensionContext): PiModel[] {
@@ -142,6 +218,114 @@ function codexAuthCandidateModels(ctx: ExtensionContext): PiModel[] {
   return candidates;
 }
 
+function readCodexCliAuth(
+  env: NodeJS.ProcessEnv,
+  now: number,
+): QuotaAuthCandidate | undefined {
+  try {
+    const payload: unknown = JSON.parse(readFileSync(codexAuthPath(env), "utf8"));
+    if (!isRecord(payload)) return undefined;
+    if (typeof payload.auth_mode === "string" && payload.auth_mode !== "chatgpt")
+      return undefined;
+    const tokens = isRecord(payload.tokens) ? payload.tokens : undefined;
+    const accessToken = typeof tokens?.access_token === "string"
+      ? tokens.access_token
+      : undefined;
+    if (!accessToken || accessToken.startsWith("sk-")) return undefined;
+    if (isExpiredToken(accessToken, now)) return undefined;
+    const accountId = stringValue(tokens?.account_id)
+      ?? chatgptAccountId(accessToken)
+      ?? (typeof tokens?.id_token === "string"
+        ? chatgptAccountId(tokens.id_token)
+        : undefined);
+    if (!accountId) return undefined;
+    return {
+      source: "codex-cli-auth",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        [CODEX_USAGE_ACCOUNT_HEADER]: accountId,
+        "User-Agent": USER_AGENT,
+        Accept: "application/json",
+      },
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function codexAuthPath(env: NodeJS.ProcessEnv): string {
+  const configured = typeof env.CODEX_HOME === "string" ? env.CODEX_HOME.trim() : "";
+  if (!configured) return join(homedir(), ".codex", "auth.json");
+  const root = configured === "~"
+    ? homedir()
+    : configured.startsWith("~/") || configured.startsWith("~\\")
+      ? join(homedir(), configured.slice(2))
+      : configured;
+  return join(root, "auth.json");
+}
+
+function stringHeaders(
+  headers: Record<string, string | null> | undefined,
+): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const [name, value] of Object.entries(headers ?? {})) {
+    if (value !== null) result[name] = value;
+  }
+  return result;
+}
+
+function hasHeader(headers: Record<string, string>, name: string): boolean {
+  return headerValue(headers, name) !== undefined;
+}
+
+function headerValue(
+  headers: Record<string, string>,
+  name: string,
+): string | undefined {
+  const expected = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === expected && value.trim()) return value;
+  }
+  return undefined;
+}
+
+function bearerToken(headers: Record<string, string>): string | undefined {
+  const value = headerValue(headers, "Authorization");
+  return /^Bearer\s+(.+)$/iu.exec(value ?? "")?.[1]?.trim();
+}
+
+function chatgptAccountId(token: string): string | undefined {
+  const payload = decodeJwtPayload(token);
+  const authClaim = payload?.[OPENAI_AUTH_CLAIM];
+  return stringValue(isRecord(authClaim) ? authClaim.chatgpt_account_id : undefined);
+}
+
+function isExpiredToken(token: string, now: number): boolean {
+  const payload = decodeJwtPayload(token);
+  const exp = payload?.exp;
+  if (typeof exp !== "number" || !Number.isFinite(exp)) return false;
+  return exp * 1000 <= now + TOKEN_EXPIRY_MARGIN_MS;
+}
+
+function decodeJwtPayload(token: string): Record<string, unknown> | undefined {
+  const encoded = token.split(".")[1];
+  if (!encoded) return undefined;
+  try {
+    const parsed: unknown = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    return isRecord(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 async function fetchWithTimeout(
   url: string,
   init: RequestInit,
@@ -390,17 +574,12 @@ class CodexAppServerClient {
 }
 
 
-function hasHeader(headers: Record<string, string>, name: string): boolean {
-  return Object.keys(headers).some(
-    (key) => key.toLowerCase() === name.toLowerCase(),
-  );
-}
-
 function redactErrorBody(body: string): string {
   return truncateEnd(
     body
       .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer <redacted>")
       .replace(/"access_token"\s*:\s*"[^"]+"/gi, '"access_token":"<redacted>"')
+      .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, "<redacted>")
       .trim(),
     MAX_ERROR_BODY_CHARS,
   );

package/node_modules/@llblab/pi-codex-usage/lib/usage.ts

@@ -8,7 +8,12 @@ export const OPENAI_USAGE_PROVIDERS = ["openai-codex", "openai"] as const;
 export function isOpenAICodexModel(model: Pick<PiModel, "provider"> | undefined): boolean {
   return OPENAI_USAGE_PROVIDERS.some((provider) => model?.provider === provider);
 }
-export type UsageSource = "pi-auth" | "codex-app-server";
+export type UsageSource =
+  | "pi-auth"
+  | "pi-auth-openai"
+  | "pi-auth-openai-codex"
+  | "codex-cli-auth"
+  | "codex-app-server";
 export type UsageQueryError = { source: UsageSource; message: string; cause?: unknown };
 export type CodexUsageReport = {
   snapshots: NormalizedRateLimitSnapshot[];
@@ -283,6 +288,9 @@ function isUnavailableError(error: UsageQueryError): boolean {
   const message = error.message.toLowerCase();
   return (
     message.includes("no pi openai codex subscription auth") ||
+    message.includes("not accepted by the codex usage endpoint") ||
+    message.includes("no usable codex cli chatgpt auth") ||
+    message.includes("subscription token has expired") ||
     message.includes("no displayable rate-limit windows") ||
     message.includes("returned no displayable rate-limit windows") ||
     message.includes("returned 401") ||

package/node_modules/@llblab/pi-codex-usage/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-codex-usage",
-  "version": "0.13.2",
+  "version": "0.13.4",
   "private": false,
   "description": "Pi extension for Codex subscription usage and an optional Fast toggle",
   "keywords": [

package/node_modules/yaml/LICENSE

@@ -0,0 +1,13 @@
+Copyright Eemeli Aro <eemeli@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/node_modules/yaml/README.md

@@ -0,0 +1,172 @@
+# YAML <a href="https://www.npmjs.com/package/yaml"><img align="right" src="https://badge.fury.io/js/yaml.svg" title="npm package" /></a>
+
+`yaml` is a definitive library for [YAML](https://yaml.org/), the human friendly data serialization standard.
+This library:
+
+- Supports both YAML 1.1 and YAML 1.2 and all common data schemas,
+- Passes all of the [yaml-test-suite](https://github.com/yaml/yaml-test-suite) tests,
+- Can accept any string as input without throwing, parsing as much YAML out of it as it can, and
+- Supports parsing, modifying, and writing YAML comments and blank lines.
+
+The library is released under the ISC open source license, and the code is [available on GitHub](https://github.com/eemeli/yaml/).
+It has no external dependencies and runs on Node.js as well as modern browsers.
+
+For the purposes of versioning, any changes that break any of the documented endpoints or APIs will be considered semver-major breaking changes.
+Undocumented library internals may change between minor versions, and previous APIs may be deprecated (but not removed).
+
+The minimum supported TypeScript version of the included typings is 3.9;
+for use in earlier versions you may need to set `skipLibCheck: true` in your config.
+This requirement may be updated between minor versions of the library.
+
+For more information, see the project's documentation site: [**eemeli.org/yaml**](https://eemeli.org/yaml/)
+
+For build instructions and contribution guidelines, see [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md).
+
+To install:
+
+```sh
+npm install yaml
+# or
+deno add jsr:@eemeli/yaml
+```
+
+**Note:** These docs are for `yaml@2`. For v1, see the [v1.10.0 tag](https://github.com/eemeli/yaml/tree/v1.10.0) for the source and [eemeli.org/yaml/v1](https://eemeli.org/yaml/v1/) for the documentation.
+
+## API Overview
+
+The API provided by `yaml` has three layers, depending on how deep you need to go: [Parse & Stringify](https://eemeli.org/yaml/#parse-amp-stringify), [Documents](https://eemeli.org/yaml/#documents), and the underlying [Lexer/Parser/Composer](https://eemeli.org/yaml/#parsing-yaml).
+The first has the simplest API and "just works", the second gets you all the bells and whistles supported by the library along with a decent [AST](https://eemeli.org/yaml/#content-nodes), and the third lets you get progressively closer to YAML source, if that's your thing.
+
+A [command-line tool](https://eemeli.org/yaml/#command-line-tool) is also included.
+
+### Parse & Stringify
+
+```js
+import { parse, stringify } from 'yaml'
+```
+
+- [`parse(str, reviver?, options?): value`](https://eemeli.org/yaml/#yaml-parse)
+- [`stringify(value, replacer?, options?): string`](https://eemeli.org/yaml/#yaml-stringify)
+
+### Documents
+
+<!-- prettier-ignore -->
+```js
+import {
+  Document,
+  isDocument,
+  parseAllDocuments,
+  parseDocument
+} from 'yaml'
+```
+
+- [`Document`](https://eemeli.org/yaml/#documents)
+  - [`constructor(value, replacer?, options?)`](https://eemeli.org/yaml/#creating-documents)
+  - [`#contents`](https://eemeli.org/yaml/#content-nodes)
+  - [`#directives`](https://eemeli.org/yaml/#stream-directives)
+  - [`#errors`](https://eemeli.org/yaml/#errors)
+  - [`#warnings`](https://eemeli.org/yaml/#errors)
+- [`isDocument(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`parseAllDocuments(str, options?): Document[]`](https://eemeli.org/yaml/#parsing-documents)
+- [`parseDocument(str, options?): Document`](https://eemeli.org/yaml/#parsing-documents)
+
+### Content Nodes
+
+<!-- prettier-ignore -->
+```js
+import {
+  isAlias, isCollection, isMap, isNode,
+  isPair, isScalar, isSeq, Scalar,
+  visit, visitAsync, YAMLMap, YAMLSeq
+} from 'yaml'
+```
+
+- [`isAlias(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isCollection(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isMap(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isNode(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isPair(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isScalar(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isSeq(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`new Scalar(value)`](https://eemeli.org/yaml/#scalar-values)
+- [`new YAMLMap()`](https://eemeli.org/yaml/#collections)
+- [`new YAMLSeq()`](https://eemeli.org/yaml/#collections)
+- [`doc.createAlias(node, name?): Alias`](https://eemeli.org/yaml/#creating-nodes)
+- [`doc.createNode(value, options?): Node`](https://eemeli.org/yaml/#creating-nodes)
+- [`doc.createPair(key, value): Pair`](https://eemeli.org/yaml/#creating-nodes)
+- [`visit(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
+- [`visitAsync(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
+
+### Parsing YAML
+
+```js
+import { Composer, Lexer, Parser } from 'yaml'
+```
+
+- [`new Lexer().lex(src)`](https://eemeli.org/yaml/#lexer)
+- [`new Parser(onNewLine?).parse(src)`](https://eemeli.org/yaml/#parser)
+- [`new Composer(options?).compose(tokens)`](https://eemeli.org/yaml/#composer)
+
+## YAML.parse
+
+```yaml
+# file.yml
+YAML:
+  - A human-readable data serialization language
+  - https://en.wikipedia.org/wiki/YAML
+yaml:
+  - A complete JavaScript implementation
+  - https://www.npmjs.com/package/yaml
+```
+
+```js
+import fs from 'fs'
+import YAML from 'yaml'
+
+YAML.parse('3.14159')
+// 3.14159
+
+YAML.parse('[ true, false, maybe, null ]\n')
+// [ true, false, 'maybe', null ]
+
+const file = fs.readFileSync('./file.yml', 'utf8')
+YAML.parse(file)
+// { YAML:
+//   [ 'A human-readable data serialization language',
+//     'https://en.wikipedia.org/wiki/YAML' ],
+//   yaml:
+//   [ 'A complete JavaScript implementation',
+//     'https://www.npmjs.com/package/yaml' ] }
+```
+
+## YAML.stringify
+
+```js
+import YAML from 'yaml'
+
+YAML.stringify(3.14159)
+// '3.14159\n'
+
+YAML.stringify([true, false, 'maybe', null])
+// `- true
+// - false
+// - maybe
+// - null
+// `
+
+YAML.stringify({ number: 3, plain: 'string', block: 'two\nlines\n' })
+// `number: 3
+// plain: string
+// block: |
+//   two
+//   lines
+// `
+```
+
+---
+
+Browser testing provided by:
+
+<a href="https://www.browserstack.com/open-source">
+<img width=200 src="https://eemeli.org/yaml/images/browserstack.svg" alt="BrowserStack" />
+</a>

package/node_modules/yaml/bin.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { UserError, cli, help } from './dist/cli.mjs'
+
+cli(process.stdin, error => {
+  if (error instanceof UserError) {
+    if (error.code === UserError.ARGS) console.error(`${help}\n`)
+    console.error(error.message)
+    process.exitCode = error.code
+  } else if (error) throw error
+})

package/node_modules/yaml/browser/dist/compose/compose-collection.js

@@ -0,0 +1,88 @@
+import { isNode } from '../nodes/identity.js';
+import { Scalar } from '../nodes/Scalar.js';
+import { YAMLMap } from '../nodes/YAMLMap.js';
+import { YAMLSeq } from '../nodes/YAMLSeq.js';
+import { resolveBlockMap } from './resolve-block-map.js';
+import { resolveBlockSeq } from './resolve-block-seq.js';
+import { resolveFlowCollection } from './resolve-flow-collection.js';
+
+function resolveCollection(CN, ctx, token, onError, tagName, tag) {
+    const coll = token.type === 'block-map'
+        ? resolveBlockMap(CN, ctx, token, onError, tag)
+        : token.type === 'block-seq'
+            ? resolveBlockSeq(CN, ctx, token, onError, tag)
+            : resolveFlowCollection(CN, ctx, token, onError, tag);
+    const Coll = coll.constructor;
+    // If we got a tagName matching the class, or the tag name is '!',
+    // then use the tagName from the node class used to create it.
+    if (tagName === '!' || tagName === Coll.tagName) {
+        coll.tag = Coll.tagName;
+        return coll;
+    }
+    if (tagName)
+        coll.tag = tagName;
+    return coll;
+}
+function composeCollection(CN, ctx, token, props, onError) {
+    const tagToken = props.tag;
+    const tagName = !tagToken
+        ? null
+        : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    if (token.type === 'block-seq') {
+        const { anchor, newlineAfterProp: nl } = props;
+        const lastProp = anchor && tagToken
+            ? anchor.offset > tagToken.offset
+                ? anchor
+                : tagToken
+            : (anchor ?? tagToken);
+        if (lastProp && (!nl || nl.offset < lastProp.offset)) {
+            const message = 'Missing newline after block sequence props';
+            onError(lastProp, 'MISSING_CHAR', message);
+        }
+    }
+    const expType = token.type === 'block-map'
+        ? 'map'
+        : token.type === 'block-seq'
+            ? 'seq'
+            : token.start.source === '{'
+                ? 'map'
+                : 'seq';
+    // shortcut: check if it's a generic YAMLMap or YAMLSeq
+    // before jumping into the custom tag logic.
+    if (!tagToken ||
+        !tagName ||
+        tagName === '!' ||
+        (tagName === YAMLMap.tagName && expType === 'map') ||
+        (tagName === YAMLSeq.tagName && expType === 'seq')) {
+        return resolveCollection(CN, ctx, token, onError, tagName);
+    }
+    let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
+    if (!tag) {
+        const kt = ctx.schema.knownTags[tagName];
+        if (kt?.collection === expType) {
+            ctx.schema.tags.push(Object.assign({}, kt, { default: false }));
+            tag = kt;
+        }
+        else {
+            if (kt) {
+                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection ?? 'scalar'}`, true);
+            }
+            else {
+                onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
+            }
+            return resolveCollection(CN, ctx, token, onError, tagName);
+        }
+    }
+    const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
+    const res = tag.resolve?.(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options) ?? coll;
+    const node = isNode(res)
+        ? res
+        : new Scalar(res);
+    node.range = coll.range;
+    node.tag = tagName;
+    if (tag?.format)
+        node.format = tag.format;
+    return node;
+}
+
+export { composeCollection };