@crouton-kit/crouter 0.3.32 → 0.3.34

package/dist/builtin-pi-packages/pi-crtr-extensions/lib/subscription-state.ts

@@ -0,0 +1,479 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import type { OAuthCredentials, ThinkingLevel } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export const ANTHROPIC_PROVIDER_ID = "anthropic";
+export const OPENAI_CODEX_PROVIDER_ID = "openai-codex";
+
+export type ManagedProviderId = typeof ANTHROPIC_PROVIDER_ID | typeof OPENAI_CODEX_PROVIDER_ID;
+export type LadderProviderId = "anthropic" | "openai";
+export type ModelStrength = "ultra" | "strong" | "medium" | "light";
+
+export type SubscriptionCredential = {
+  label: string;
+  refresh: string;
+  access: string;
+  expires: number;
+  rateLimitedUntil: number;
+  lastAttemptAt: number;
+  lastRateLimitedAt: number;
+};
+
+export type ModelRef = {
+  providerId: ManagedProviderId;
+  modelId: string;
+};
+
+export type RotationConfig = {
+  defaultFallbackStrength?: ModelStrength;
+  revertWhenAvailable?: boolean;
+  preferredModel?: ModelRef;
+};
+
+type RotationConfigUpdate = {
+  defaultFallbackStrength?: ModelStrength;
+  revertWhenAvailable?: boolean;
+  preferredModel?: ModelRef | null;
+};
+
+export type FallbackTarget = {
+  providerId: ManagedProviderId;
+  modelId: string;
+  label: string;
+  strength: ModelStrength;
+  thinkingLevel?: ThinkingLevel;
+};
+
+type ModelLadderConfig = Partial<Record<ModelStrength, string>>;
+type ModelLaddersConfig = Partial<Record<LadderProviderId, ModelLadderConfig>>;
+type AuthFile = Record<string, OAuthCredentials & { type?: string }>;
+
+const AGENT_DIR = join(homedir(), ".pi", "agent");
+const AUTH_FILE = join(AGENT_DIR, "auth.json");
+const ROTATION_CONFIG_FILE = join(AGENT_DIR, "provider-rotation.json");
+const CROUTER_CONFIG_FILE = join(homedir(), ".crouter", "config.json");
+const DEFAULT_FALLBACK_STRENGTH: ModelStrength = "strong";
+
+const PROVIDERS: Record<
+  ManagedProviderId,
+  {
+    label: string;
+    ladderProviderId: LadderProviderId;
+    poolFile: string;
+  }
+> = {
+  [ANTHROPIC_PROVIDER_ID]: {
+    label: "Claude",
+    ladderProviderId: "anthropic",
+    poolFile: join(AGENT_DIR, "anthropic-subscriptions.json"),
+  },
+  [OPENAI_CODEX_PROVIDER_ID]: {
+    label: "OpenAI Codex",
+    ladderProviderId: "openai",
+    poolFile: join(AGENT_DIR, "openai-codex-subscriptions.json"),
+  },
+};
+
+function readJsonFile<T>(path: string): T | undefined {
+  if (!existsSync(path)) return undefined;
+  try {
+    const raw = readFileSync(path, "utf8").trim();
+    if (!raw) return undefined;
+    return JSON.parse(raw) as T;
+  } catch {
+    return undefined;
+  }
+}
+
+function writeJsonFile(path: string, value: unknown): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+  renameSync(tmp, path);
+}
+
+function normalizeStrength(value: unknown): ModelStrength | undefined {
+  return value === "ultra" || value === "strong" || value === "medium" || value === "light" ? value : undefined;
+}
+
+function normalizeTiming(value: unknown): number {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : 0;
+}
+
+function normalizeCredential(value: Partial<SubscriptionCredential> & { label?: string }): SubscriptionCredential | undefined {
+  const label = typeof value.label === "string" ? value.label.trim() : "";
+  const refresh = typeof value.refresh === "string" ? value.refresh.trim() : "";
+  const access = typeof value.access === "string" ? value.access.trim() : "";
+  if (!label || !refresh || !access) return undefined;
+  const expires = Number(value.expires);
+  const rateLimitedUntil = Number(value.rateLimitedUntil);
+  return {
+    label,
+    refresh,
+    access,
+    expires: Number.isFinite(expires) ? expires : 0,
+    rateLimitedUntil: Number.isFinite(rateLimitedUntil) ? rateLimitedUntil : 0,
+    lastAttemptAt: normalizeTiming(value.lastAttemptAt),
+    lastRateLimitedAt: normalizeTiming(value.lastRateLimitedAt),
+  };
+}
+
+function normalizeCredentials(values: unknown): SubscriptionCredential[] {
+  if (!Array.isArray(values)) return [];
+  return values.map((entry) => normalizeCredential(entry as Partial<SubscriptionCredential> & { label?: string })).filter((entry): entry is SubscriptionCredential => Boolean(entry));
+}
+
+function readAuthCredentials(): AuthFile {
+  return readJsonFile<AuthFile>(AUTH_FILE) ?? {};
+}
+
+function getCurrentModelRef(model?: { provider: string; id: string }): ModelRef | undefined {
+  return isManagedProvider(model?.provider) ? { providerId: model.provider, modelId: model.id } : undefined;
+}
+
+function seedSubscriptionsFromAuth(providerId: ManagedProviderId): SubscriptionCredential[] {
+  const credential = readAuthCredentials()[providerId];
+  if (!credential) return [];
+  const seeded = normalizeCredential({
+    label: providerId,
+    refresh: credential.refresh,
+    access: credential.access,
+    expires: credential.expires,
+    rateLimitedUntil: 0,
+    lastAttemptAt: 0,
+    lastRateLimitedAt: 0,
+  });
+  return seeded ? [seeded] : [];
+}
+
+function syncDefaultSubscriptionFromAuth(providerId: ManagedProviderId, pool: SubscriptionCredential[]): SubscriptionCredential[] {
+  const [seeded] = seedSubscriptionsFromAuth(providerId);
+  if (!seeded) return pool;
+  if (pool.length === 0) return [seeded];
+
+  // `/login` ambiently writes the freshly authenticated credential to auth.json.
+  // If it matches a pool entry by token, sync that entry in place; otherwise it's
+  // re-auth on the selected/default slot (index 0) whose tokens rotated enough
+  // that they no longer match, so update that slot rather than appending a new
+  // entry. Adding a genuinely additional account is an explicit action only:
+  // `/provider-sub <provider> add <label>`.
+  const sameCredential = pool.findIndex((entry) => entry.refresh === seeded.refresh || entry.access === seeded.access);
+  const targetIndex = sameCredential === -1 ? 0 : sameCredential;
+  const current = pool[targetIndex];
+  if (current.refresh === seeded.refresh && current.access === seeded.access && current.expires === seeded.expires) return pool;
+  const next = [...pool];
+  next[targetIndex] = {
+    ...current,
+    refresh: seeded.refresh,
+    access: seeded.access,
+    expires: seeded.expires,
+    rateLimitedUntil: 0,
+  };
+  return writeSubscriptionPool(providerId, next);
+}
+
+export function isManagedProvider(providerId: string | undefined): providerId is ManagedProviderId {
+  return providerId === ANTHROPIC_PROVIDER_ID || providerId === OPENAI_CODEX_PROVIDER_ID;
+}
+
+export function getProviderLabel(providerId: ManagedProviderId): string {
+  return PROVIDERS[providerId].label;
+}
+
+export function readSubscriptionPool(providerId: ManagedProviderId): SubscriptionCredential[] {
+  const poolFile = PROVIDERS[providerId].poolFile;
+  const normalized = normalizeCredentials(readJsonFile<unknown>(poolFile));
+  if (normalized.length > 0) return syncDefaultSubscriptionFromAuth(providerId, normalized);
+
+  const seeded = seedSubscriptionsFromAuth(providerId);
+  if (seeded.length > 0) writeSubscriptionPool(providerId, seeded);
+  return seeded;
+}
+
+export function writeSubscriptionPool(providerId: ManagedProviderId, next: SubscriptionCredential[]): SubscriptionCredential[] {
+  const normalized = normalizeCredentials(next);
+  writeJsonFile(PROVIDERS[providerId].poolFile, normalized);
+  return normalized;
+}
+
+function resolveCredentialIndex(pool: SubscriptionCredential[], ref: string): number {
+  const needle = ref.trim().toLowerCase();
+  const numeric = Number.parseInt(needle, 10);
+  if (Number.isFinite(numeric) && String(numeric) === needle && numeric >= 1 && numeric <= pool.length) {
+    return numeric - 1;
+  }
+  return pool.findIndex((entry) => entry.label.toLowerCase() === needle);
+}
+
+export function upsertSubscription(providerId: ManagedProviderId, next: SubscriptionCredential): SubscriptionCredential[] {
+  const pool = readSubscriptionPool(providerId);
+  const index = pool.findIndex((entry) => entry.label.toLowerCase() === next.label.toLowerCase());
+  if (index === -1) pool.push(next);
+  else pool[index] = next;
+  return writeSubscriptionPool(providerId, pool);
+}
+
+export function removeSubscription(providerId: ManagedProviderId, ref: string): SubscriptionCredential[] {
+  const pool = readSubscriptionPool(providerId);
+  const index = resolveCredentialIndex(pool, ref);
+  if (index === -1) throw new Error(`Unknown ${getProviderLabel(providerId)} subscription: ${ref}`);
+  pool.splice(index, 1);
+  return writeSubscriptionPool(providerId, pool);
+}
+
+export function promoteSubscription(providerId: ManagedProviderId, ref: string): SubscriptionCredential[] {
+  const pool = readSubscriptionPool(providerId);
+  const index = resolveCredentialIndex(pool, ref);
+  if (index === -1) throw new Error(`Unknown ${getProviderLabel(providerId)} subscription: ${ref}`);
+  if (index > 0) pool.unshift(pool.splice(index, 1)[0]);
+  return writeSubscriptionPool(providerId, pool);
+}
+
+export function markSubscriptionAttempt(providerId: ManagedProviderId, ref: string, attemptAt = Date.now()): SubscriptionCredential[] {
+  const pool = readSubscriptionPool(providerId);
+  const index = resolveCredentialIndex(pool, ref);
+  if (index === -1) throw new Error(`Unknown ${getProviderLabel(providerId)} subscription: ${ref}`);
+  pool[index] = {
+    ...pool[index],
+    lastAttemptAt: Math.max(pool[index].lastAttemptAt, attemptAt),
+  };
+  return writeSubscriptionPool(providerId, pool);
+}
+
+export function markSubscriptionRateLimited(
+  providerId: ManagedProviderId,
+  ref: string,
+  retryAfterMs: number,
+  attemptAt = Date.now(),
+  rateLimitedAt = Date.now(),
+): SubscriptionCredential[] {
+  const pool = readSubscriptionPool(providerId);
+  const index = resolveCredentialIndex(pool, ref);
+  if (index === -1) throw new Error(`Unknown ${getProviderLabel(providerId)} subscription: ${ref}`);
+  if (rateLimitedAt < pool[index].lastRateLimitedAt) return pool;
+  pool[index] = {
+    ...pool[index],
+    lastAttemptAt: Math.max(pool[index].lastAttemptAt, attemptAt),
+    lastRateLimitedAt: Math.max(pool[index].lastRateLimitedAt, rateLimitedAt),
+    rateLimitedUntil: rateLimitedAt + Math.max(0, retryAfterMs),
+  };
+  return writeSubscriptionPool(providerId, pool);
+}
+
+export function markSubscriptionSuccess(providerId: ManagedProviderId, ref: string, attemptAt = Date.now()): SubscriptionCredential[] {
+  const pool = readSubscriptionPool(providerId);
+  const index = resolveCredentialIndex(pool, ref);
+  if (index === -1) throw new Error(`Unknown ${getProviderLabel(providerId)} subscription: ${ref}`);
+  if (attemptAt < pool[index].lastRateLimitedAt) return pool;
+  pool[index] = {
+    ...pool[index],
+    lastAttemptAt: Math.max(pool[index].lastAttemptAt, attemptAt),
+    rateLimitedUntil: 0,
+  };
+  return writeSubscriptionPool(providerId, pool);
+}
+
+export function findAvailableSubscription(providerId: ManagedProviderId, now = Date.now()): SubscriptionCredential | undefined {
+  return readSubscriptionPool(providerId).find((entry) => !entry.rateLimitedUntil || entry.rateLimitedUntil <= now);
+}
+
+export function parseRetryAfterHeader(value: string | undefined, now = Date.now()): number | undefined {
+  if (!value) return undefined;
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds)) return Math.max(0, Math.round(seconds * 1000));
+  const parsed = Date.parse(trimmed);
+  return Number.isFinite(parsed) ? Math.max(0, parsed - now) : undefined;
+}
+
+function thinkingLevelOfRef(ref: string): ThinkingLevel | undefined {
+  const match = ref.trim().match(/:(thinking|off|minimal|low|medium|high|xhigh)$/i);
+  if (!match) return undefined;
+  const level = match[1].toLowerCase();
+  return level === "off" || level === "thinking" ? undefined : (level as ThinkingLevel);
+}
+
+function normalizeModelRef(ref: string): string {
+  return ref
+    .trim()
+    .replace(/^[^/]+\//, "")
+    .replace(/:(?:thinking|off|minimal|low|medium|high|xhigh)$/i, "")
+    .toLowerCase();
+}
+
+function splitModelRef(ref: string): FallbackTarget {
+  const trimmed = ref.trim();
+  const slash = trimmed.indexOf("/");
+  const providerId = slash === -1 ? OPENAI_CODEX_PROVIDER_ID : trimmed.slice(0, slash).trim();
+  if (!isManagedProvider(providerId)) {
+    throw new Error(`Unsupported fallback provider: ${providerId}`);
+  }
+  const rawModelId = slash === -1 ? trimmed : trimmed.slice(slash + 1).trim();
+  const thinkingMatch = rawModelId.match(/^(.*?)(?::(thinking|off|minimal|low|medium|high|xhigh))$/i);
+  return {
+    providerId,
+    modelId: thinkingMatch ? thinkingMatch[1] : rawModelId,
+    label: `${providerId}/${thinkingMatch ? thinkingMatch[1] : rawModelId}${thinkingMatch?.[2] ? `:${thinkingMatch[2].toLowerCase()}` : ""}`,
+    strength: DEFAULT_FALLBACK_STRENGTH,
+    thinkingLevel: thinkingMatch?.[2] && thinkingMatch[2].toLowerCase() !== "off" && thinkingMatch[2].toLowerCase() !== "thinking"
+      ? (thinkingMatch[2].toLowerCase() as ThinkingLevel)
+      : undefined,
+  };
+}
+
+function readModelLadders(): ModelLaddersConfig | undefined {
+  const config = readJsonFile<{ modelLadders?: Partial<Record<LadderProviderId, Partial<ModelLadderConfig>>> }>(CROUTER_CONFIG_FILE);
+  const ladders = config?.modelLadders;
+  if (!ladders) return undefined;
+  const result: ModelLaddersConfig = {};
+  for (const provider of ["anthropic", "openai"] as const) {
+    const source = ladders[provider];
+    if (!source) continue;
+    const normalized: ModelLadderConfig = {};
+    for (const strength of ["ultra", "strong", "medium", "light"] as const) {
+      const value = typeof source[strength] === "string" ? source[strength]?.trim() : "";
+      if (value) normalized[strength] = value;
+    }
+    if (Object.keys(normalized).length > 0) result[provider] = normalized;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+function findStrengthForModelId(
+  providerId: ManagedProviderId,
+  modelId: string | undefined,
+  defaultStrength: ModelStrength,
+  ladders = readModelLadders(),
+  currentThinkingLevel?: string,
+): ModelStrength | undefined {
+  const source = ladders?.[PROVIDERS[providerId].ladderProviderId];
+  const bareId = modelId ? normalizeModelRef(modelId) : undefined;
+  if (!source || !bareId) return undefined;
+  const matches: ModelStrength[] = [];
+  for (const strength of ["ultra", "strong", "medium", "light"] as const) {
+    const ref = source[strength];
+    if (ref && normalizeModelRef(ref) === bareId) matches.push(strength);
+  }
+  if (matches.length === 0) return undefined;
+  // Rungs that share a bare model id (e.g. gpt-5.5:xhigh vs gpt-5.5:high) are
+  // disambiguated by the live reasoning level so an ultra run doesn't collapse to strong.
+  if (matches.length > 1 && currentThinkingLevel) {
+    const exact = matches.find((strength) => thinkingLevelOfRef(source[strength]!) === currentThinkingLevel);
+    if (exact) return exact;
+  }
+  return matches.includes(defaultStrength) ? defaultStrength : matches[0];
+}
+
+export function readRotationConfig(): RotationConfig {
+  const raw = readJsonFile<RotationConfig>(ROTATION_CONFIG_FILE) ?? {};
+  const preferredModel =
+    raw.preferredModel && isManagedProvider(raw.preferredModel.providerId) && typeof raw.preferredModel.modelId === "string"
+      ? { providerId: raw.preferredModel.providerId, modelId: raw.preferredModel.modelId.trim() }
+      : undefined;
+  return {
+    defaultFallbackStrength: normalizeStrength(raw.defaultFallbackStrength) ?? DEFAULT_FALLBACK_STRENGTH,
+    revertWhenAvailable: raw.revertWhenAvailable ?? true,
+    preferredModel,
+  };
+}
+
+export function writeRotationConfig(next: RotationConfigUpdate): RotationConfig {
+  const current = readRotationConfig();
+  const merged: RotationConfig = {
+    defaultFallbackStrength: normalizeStrength(next.defaultFallbackStrength) ?? current.defaultFallbackStrength ?? DEFAULT_FALLBACK_STRENGTH,
+    revertWhenAvailable: next.revertWhenAvailable ?? current.revertWhenAvailable ?? true,
+    preferredModel: Object.prototype.hasOwnProperty.call(next, "preferredModel")
+      ? next.preferredModel || undefined
+      : current.preferredModel,
+  };
+  writeJsonFile(ROTATION_CONFIG_FILE, merged);
+  return merged;
+}
+
+export function clearPreferredModel(): RotationConfig {
+  return writeRotationConfig({ preferredModel: null });
+}
+
+export function rememberPreferredModel(model: ModelRef): RotationConfig {
+  return writeRotationConfig({ preferredModel: model });
+}
+
+export function resolveFallbackTarget(
+  currentProviderId: ManagedProviderId,
+  currentModelId?: string,
+  config = readRotationConfig(),
+  currentThinkingLevel?: string,
+): FallbackTarget {
+  const ladders = readModelLadders();
+  const defaultStrength = config.defaultFallbackStrength ?? DEFAULT_FALLBACK_STRENGTH;
+  const sourceStrength = findStrengthForModelId(currentProviderId, currentModelId, defaultStrength, ladders, currentThinkingLevel);
+  const strength = sourceStrength ?? defaultStrength;
+  const targetProvider = currentProviderId === ANTHROPIC_PROVIDER_ID ? OPENAI_CODEX_PROVIDER_ID : ANTHROPIC_PROVIDER_ID;
+  const targetLadder = ladders?.[PROVIDERS[targetProvider].ladderProviderId];
+  const candidates = strength === defaultStrength ? [strength] : [strength, defaultStrength];
+  const fallbackRef = candidates.map((candidate) => targetLadder?.[candidate]).find((ref): ref is string => typeof ref === "string" && ref.trim().length > 0);
+  if (!fallbackRef) {
+    throw new Error(`Unable to resolve fallback model for strength ${strength}; configure a ${PROVIDERS[targetProvider].ladderProviderId} ladder in ~/.crouter/config.json`);
+  }
+  const parsed = splitModelRef(fallbackRef);
+  const resolvedStrength = candidates.find((candidate) => targetLadder?.[candidate] === fallbackRef) ?? strength;
+  return { ...parsed, strength: resolvedStrength };
+}
+
+export function shouldRestorePreferredModel(config = readRotationConfig(), now = Date.now()): boolean {
+  if (!config.revertWhenAvailable || !config.preferredModel) return false;
+  return Boolean(findAvailableSubscription(config.preferredModel.providerId, now));
+}
+
+export async function restorePreferredModelIfPossible(
+  piApi: ExtensionAPI,
+  ctx: Pick<ExtensionContext, "model" | "modelRegistry">,
+): Promise<boolean> {
+  const config = readRotationConfig();
+  if (!shouldRestorePreferredModel(config, Date.now())) return false;
+  const preferred = config.preferredModel;
+  if (!preferred) return false;
+  const current = getCurrentModelRef(ctx.model);
+  if (current?.providerId === preferred.providerId && current.modelId === preferred.modelId) {
+    clearPreferredModel();
+    return true;
+  }
+  const model = ctx.modelRegistry.find(preferred.providerId, preferred.modelId);
+  if (!model) return false;
+  const switched = await piApi.setModel(model);
+  if (switched) clearPreferredModel();
+  return switched;
+}
+
+export async function switchToFallbackIfPossible(
+  piApi: ExtensionAPI,
+  ctx: Pick<ExtensionContext, "model" | "modelRegistry">,
+  preferredModel = getCurrentModelRef(ctx.model),
+): Promise<FallbackTarget | undefined> {
+  if (!preferredModel) return undefined;
+  rememberPreferredModel(preferredModel);
+  const currentThinkingLevel = piApi.getThinkingLevel?.();
+  const target = resolveFallbackTarget(preferredModel.providerId, preferredModel.modelId, readRotationConfig(), currentThinkingLevel);
+  const current = getCurrentModelRef(ctx.model);
+  const model = ctx.modelRegistry.find(target.providerId, target.modelId);
+  if (!model) return undefined;
+  if (current?.providerId !== target.providerId || current.modelId !== target.modelId) {
+    const switched = await piApi.setModel(model);
+    if (!switched) return undefined;
+  }
+  if (target.thinkingLevel) piApi.setThinkingLevel(target.thinkingLevel);
+  return target;
+}
+
+export function formatStatusLine(providerId: ManagedProviderId, now = Date.now()): string {
+  const pool = readSubscriptionPool(providerId);
+  const fallback = resolveFallbackTarget(providerId, undefined, readRotationConfig());
+  const ready = pool.filter((entry) => !entry.rateLimitedUntil || entry.rateLimitedUntil <= now);
+  const label = getProviderLabel(providerId);
+  if (ready.length === 0) return `${label} pool exhausted -> ${fallback.label}`;
+  return `${label} ${ready[0]?.label ?? providerId} (${ready.length}/${pool.length} ready)`;
+}

package/dist/builtin-pi-packages/pi-crtr-extensions/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/dist/builtin-pi-packages/pi-crtr-extensions/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/dist/builtin-pi-packages/pi-crtr-extensions/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
+})