@north-light/crouter 0.3.154

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/statusline.ts

@@ -0,0 +1,255 @@
+/**
+ * Statusline + session-name badge.
+ *
+ * Footer (statusline): <model> [· subscription] · <tokens used> · <cycle>, with
+ *                      <cwd last dir> (<git>) right-aligned on the far right.
+ * Input bar border:    session name rendered as a solid-background badge,
+ *                      shown only when a name is set (via /name or
+ *                      pi.setSessionName()).
+ *
+ * This extension owns only the statusline and session-name badge. Canvas
+ * navigation and interactive chrome live in crouter's attach viewer.
+ */
+
+import { execFile } from "node:child_process";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { CustomEditor, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+function lastDir(cwd: string): string {
+	const trimmed = cwd.replace(/\/+$/, "");
+	const base = trimmed.split("/").pop();
+	return base && base.length > 0 ? base : "/";
+}
+
+function fmtTokens(n: number): string {
+	return n < 1000 ? `${n}` : `${Math.round(n / 1000)}k`;
+}
+
+interface GitStatus {
+	staged: number;
+	modified: number;
+	untracked: number;
+	conflicts: number;
+	ahead: number;
+	behind: number;
+	stashed: number;
+}
+
+/** Run `git status --porcelain=v1 --branch` and parse a summary. */
+function loadGitStatus(cwd: string): Promise<GitStatus | null> {
+	return new Promise((resolve) => {
+		execFile(
+			"git",
+			["status", "--porcelain=v1", "--branch", "--untracked-files=all"],
+			{ cwd, timeout: 2000, windowsHide: true },
+			(err, stdout) => {
+				if (err) return resolve(null);
+				const s: GitStatus = {
+					staged: 0,
+					modified: 0,
+					untracked: 0,
+					conflicts: 0,
+					ahead: 0,
+					behind: 0,
+					stashed: 0,
+				};
+				for (const line of stdout.split("\n")) {
+					if (line.startsWith("## ")) {
+						const ahead = line.match(/ahead (\d+)/);
+						const behind = line.match(/behind (\d+)/);
+						if (ahead) s.ahead = Number(ahead[1]);
+						if (behind) s.behind = Number(behind[1]);
+						continue;
+					}
+					if (line.length < 2) continue;
+					const x = line[0];
+					const y = line[1];
+					if (x === "?" && y === "?") {
+						s.untracked++;
+					} else if (x === "U" || y === "U" || (x === "A" && y === "A") || (x === "D" && y === "D")) {
+						s.conflicts++;
+					} else {
+						if (x !== " " && x !== "?") s.staged++;
+						if (y !== " " && y !== "?") s.modified++;
+					}
+				}
+				resolve(s);
+			},
+		);
+	});
+}
+
+/** Render git status using standard prompt symbols. */
+function fmtGitStatus(s: GitStatus | null): string {
+	if (!s) return "";
+	const parts: string[] = [];
+	if (s.ahead) parts.push(`⇡${s.ahead}`); // ⇡ ahead
+	if (s.behind) parts.push(`⇣${s.behind}`); // ⇣ behind
+	if (s.conflicts) parts.push(`×${s.conflicts}`); // × conflicts
+	if (s.staged) parts.push(`+${s.staged}`); // + staged
+	if (s.modified) parts.push(`!${s.modified}`); // ! modified
+	if (s.untracked) parts.push(`?${s.untracked}`); // ? untracked
+	if (s.stashed) parts.push(`$${s.stashed}`); // $ stashed
+	if (parts.length === 0) return "✓"; // ✓ clean
+	return parts.join(" ");
+}
+
+function formatTokens(ctx: Pick<ExtensionContext, "getContextUsage">): string {
+	const usage = ctx.getContextUsage();
+	if (!usage || usage.tokens == null) return "0 tokens";
+	return `${fmtTokens(usage.tokens)} tokens`;
+}
+
+interface FooterDataLike {
+	// pi's provider reports "no branch" as null; keep undefined too so tests can pass a
+	// bare stub.
+	getGitBranch(): string | null | undefined;
+	getExtensionStatuses(): ReadonlyMap<string, string>;
+}
+
+export function buildStatuslineFooterLine(
+	width: number,
+	ctx: Pick<ExtensionContext, "cwd" | "model" | "getContextUsage">,
+	footerData: FooterDataLike,
+	gitStatus: GitStatus | null,
+): string {
+	if (width <= 0) return "";
+
+	const cwd = lastDir(ctx.cwd);
+	const branch = footerData.getGitBranch();
+	const status = fmtGitStatus(gitStatus);
+	const gitStr = branch
+		? status
+			? `${branch} ${status}`
+			: branch
+		: "";
+	const cwdStr = gitStr ? `${cwd} (${gitStr})` : cwd;
+
+	const model = ctx.model?.id ?? "no model";
+	const subscription = footerData.getExtensionStatuses().get("provider-rotation")?.trim() ?? "";
+	const tokens = formatTokens(ctx);
+	const cyclesEnv = process.env["CRTR_CYCLES"]?.trim();
+	const cycleCount = cyclesEnv ? Number.parseInt(cyclesEnv, 10) : Number.NaN;
+	const cycle = Number.isFinite(cycleCount) ? `↻${cycleCount}` : "";
+
+	const leftParts = [model];
+	if (subscription !== "") leftParts.push(subscription);
+	leftParts.push(tokens);
+	if (cycle !== "") leftParts.push(cycle);
+	const leftRaw = leftParts.join(" · ");
+	let rightRaw = cwdStr;
+
+	let rightWidth = visibleWidth(rightRaw);
+	if (rightWidth > width) {
+		const cwdWidth = visibleWidth(cwd);
+		if (cwdWidth < width) {
+			rightRaw = cwd;
+			rightWidth = cwdWidth;
+		} else {
+			return truncateToWidth(cwd, width);
+		}
+	}
+
+	if (rightWidth === width) return rightRaw;
+
+	const leftLimit = Math.max(0, width - rightWidth - 1);
+	const leftRawClamped = truncateToWidth(leftRaw, leftLimit);
+	const leftWidth = visibleWidth(leftRawClamped);
+	const padWidth = Math.max(1, width - leftWidth - rightWidth);
+	return `${leftRawClamped}${" ".repeat(padWidth)}${rightRaw}`;
+}
+
+/** Insert `badge` into a single border line at the left, after one corner cell. */
+function borderWithBadge(
+	width: number,
+	badge: string,
+	border: (text: string) => string,
+): string {
+	if (width <= 0) return "";
+	const badgeWidth = visibleWidth(badge);
+	// 1 leading border cell + badge + fill out to width.
+	if (badgeWidth + 1 >= width) {
+		return border("─") + truncateToWidth(badge, Math.max(0, width - 1), "");
+	}
+	const fill = border("─".repeat(width - 1 - badgeWidth));
+	return `${border("─")}${badge}${fill}`;
+}
+
+export default function (pi: ExtensionAPI) {
+	pi.on("session_start", (_event, ctx) => {
+		// --- Statusline (footer): model · [subscription] · tokens · cycle, with cwd/git right-aligned ---
+		ctx.ui.setFooter((tui, theme, footerData) => {
+			let gitStatus: GitStatus | null = null;
+
+			const refreshStatus = () => {
+				if (!footerData.getGitBranch()) {
+					if (gitStatus) {
+						gitStatus = null;
+						tui.requestRender();
+					}
+					return;
+				}
+				void loadGitStatus(ctx.cwd).then((next) => {
+					if (JSON.stringify(next) !== JSON.stringify(gitStatus)) {
+						gitStatus = next;
+						tui.requestRender();
+					}
+				});
+			};
+
+			refreshStatus();
+			const unsubBranch = footerData.onBranchChange(() => {
+				tui.requestRender();
+				refreshStatus();
+			});
+			const timer = setInterval(refreshStatus, 4000);
+
+			return {
+				dispose() {
+					unsubBranch();
+					clearInterval(timer);
+				},
+				invalidate() {},
+				render(width: number): string[] {
+					return [theme.fg("dim", buildStatuslineFooterLine(width, ctx, footerData, gitStatus))];
+				},
+			};
+		});
+
+		// --- Input bar border: session-name badge with solid background ---
+		// Compose with whatever editor is already installed (e.g. the mode-switch
+		// badge on the bottom border) instead of replacing it: wrap the previous
+		// factory in a Proxy that overrides only render (session-name badge on the
+		// top border). Other editor decorations keep working regardless of load
+		// order.
+		const previousEditorFactory = ctx.ui.getEditorComponent();
+		ctx.ui.setEditorComponent((tui, theme, keybindings) => {
+			const base = (
+				previousEditorFactory
+					? previousEditorFactory(tui, theme, keybindings)
+					: new CustomEditor(tui, theme, keybindings)
+			) as unknown as CustomEditor;
+
+			const render = (width: number): string[] => {
+				const lines = base.render(width);
+				const name = pi.getSessionName();
+				if (!name || lines.length === 0) return lines;
+
+				const thm = ctx.ui.theme;
+				const badge = thm.bg("selectedBg", thm.fg("text", ` ${name} `));
+				const borderColor = (text: string) => base.borderColor(text);
+				lines[0] = borderWithBadge(width, badge, borderColor);
+				return lines;
+			};
+
+			return new Proxy(base, {
+				get(target, prop) {
+					if (prop === "render") return render;
+					const value = Reflect.get(target, prop, target);
+					return typeof value === "function" ? value.bind(target) : value;
+				},
+			});
+		});
+	});
+}

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/strip-skills-docs.ts

@@ -0,0 +1,47 @@
+/**
+ * Strip pi's "Pi documentation" block from the system prompt.
+ *
+ * Pi core hardcodes a "Pi documentation (read only when the user asks about pi
+ * itself, its SDK, extensions, themes, skills, or TUI):" block — a marker line
+ * plus a bullet list pointing at pi's README / docs / examples under
+ * node_modules. It causes two problems we fix by removing the whole block:
+ *
+ *  1. It maps topics to doc files (`skills (docs/skills.md)`, etc.), which makes
+ *     the agent extrapolate a topic -> docs/<topic>.md pattern and surface pi's
+ *     internal skill system when we don't want it referenced.
+ *  2. It is a THIRD-PARTY TELL. When authenticating a Claude subscription over
+ *     OAuth, Anthropic inspects the request and — if it doesn't look like genuine
+ *     Claude Code — routes it to "extra usage" instead of the plan, returning
+ *     HTTP 400 ("Third-party apps now draw from your extra usage..."). The
+ *     companion `pi-claude-oauth-adapter` normally strips this block for exactly
+ *     that reason, but it matches the marker string INCLUDING the word "skills,"
+ *     — and the earlier version of THIS extension mangled that marker (it removed
+ *     just the "skills" word), so the adapter's match failed and the block leaked
+ *     to the wire → every subscription turn 400'd. Removing the entire block here
+ *     is self-contained: it fixes the leak regardless of the adapter's marker,
+ *     load order, or presence, and subsumes the old skill-reference removal.
+ *
+ * Runs in `before_agent_start` so it survives `pi update` / `brew upgrade`
+ * (which would overwrite any edit to the installed dist), and degrades to a
+ * no-op if pi changes the wording.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+// Matches the whole block: the "Pi documentation (read only ...):" marker line
+// (with or without the "skills," enumeration) plus its trailing "- ..." bullets,
+// and any leading blank lines so the surrounding prompt closes up cleanly.
+const PI_DOCS_BLOCK = /\n*^Pi documentation \(read only[^\n]*:(?:\n[ \t]*-[^\n]*)*/m;
+
+function stripPiDocsBlock(prompt: string): string {
+	if (!prompt.includes("Pi documentation (read only")) return prompt; // no-op / wording changed
+	return prompt.replace(PI_DOCS_BLOCK, "").trimEnd() + "\n";
+}
+
+export default function stripSkillsDocs(pi: ExtensionAPI) {
+	pi.on("before_agent_start", async (event) => {
+		const stripped = stripPiDocsBlock(event.systemPrompt);
+		if (stripped === event.systemPrompt) return;
+		return { systemPrompt: stripped };
+	});
+}

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/sysprompt-window.ts

@@ -0,0 +1,19 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const exec = promisify(execFile);
+const CRTR = "crtr";
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("sysprompt", {
+    description: "Open the calling node's system prompt in a tmux window",
+    handler: async (_args, ctx) => {
+      try {
+        await exec(CRTR, ["sys", "sysprompt", "--window"]);
+      } catch (err: any) {
+        ctx.ui.notify(err instanceof Error ? err.message : String(err), "error");
+      }
+    },
+  });
+}

package/dist/builtin-pi-packages/pi-crtr-extensions/lib/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

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

@@ -0,0 +1 @@
+export * from "./subscription-state.ts";

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

@@ -0,0 +1,2 @@
+// Provider pool state belongs to crouter core so every human surface and the rotation runtime share one invariant-preserving implementation.
+export * from "../../../core/subscription-state.js";

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
+})

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

package/dist/builtin-pi-packages/pi-crtr-extensions/node_modules/yaml/browser/dist/compose/compose-doc.js

@@ -0,0 +1,43 @@
+import { Document } from '../doc/Document.js';
+import { composeNode, composeEmptyNode } from './compose-node.js';
+import { resolveEnd } from './resolve-end.js';
+import { resolveProps } from './resolve-props.js';
+
+function composeDoc(options, directives, { offset, start, value, end }, onError) {
+    const opts = Object.assign({ _directives: directives }, options);
+    const doc = new Document(undefined, opts);
+    const ctx = {
+        atKey: false,
+        atRoot: true,
+        directives: doc.directives,
+        options: doc.options,
+        schema: doc.schema
+    };
+    const props = resolveProps(start, {
+        indicator: 'doc-start',
+        next: value ?? end?.[0],
+        offset,
+        onError,
+        parentIndent: 0,
+        startOnNewline: true
+    });
+    if (props.found) {
+        doc.directives.docStart = true;
+        if (value &&
+            (value.type === 'block-map' || value.type === 'block-seq') &&
+            !props.hasNewline)
+            onError(props.end, 'MISSING_CHAR', 'Block collection cannot start on same line with directives-end marker');
+    }
+    // @ts-expect-error If Contents is set, let's trust the user
+    doc.contents = value
+        ? composeNode(ctx, value, props, onError)
+        : composeEmptyNode(ctx, props.end, start, null, props, onError);
+    const contentEnd = doc.contents.range[2];
+    const re = resolveEnd(end, contentEnd, false, onError);
+    if (re.comment)
+        doc.comment = re.comment;
+    doc.range = [offset, contentEnd, re.offset];
+    return doc;
+}
+
+export { composeDoc };