superpowers-manager 0.9.1 → 0.10.0

package/dist/harnesses/hermes/paths.js

@@ -0,0 +1,61 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { assertNoFollowType } from "../../safe-path.js";
+function trimHome(value) {
+    const whitespace = (index) => {
+        const code = value.charCodeAt(index);
+        return ((code >= 0x1c && code <= 0x1f) ||
+            /\p{White_Space}/u.test(value.charAt(index)));
+    };
+    let start = 0;
+    let end = value.length;
+    while (start < end && whitespace(start))
+        start++;
+    while (end > start && whitespace(end - 1))
+        end--;
+    return value.slice(start, end);
+}
+function expandHome(value, env, home) {
+    const expanded = trimHome(value).replace(/\$([A-Za-z0-9_]+|\{[^}]*\})/gu, (token, name) => {
+        const variable = name.startsWith("{") ? name.slice(1, -1) : name;
+        return Object.hasOwn(env, variable) ? (env[variable] ?? token) : token;
+    });
+    if (expanded === "~")
+        return home;
+    if (expanded.startsWith("~/"))
+        return join(home, expanded.slice(2));
+    if (expanded.startsWith("~"))
+        throw new Error("cannot resolve HERMES_HOME: named user homes are unsupported");
+    return expanded;
+}
+export function hermesPaths(env, cwd) {
+    const configured = trimHome(env.HERMES_HOME ?? "");
+    const home = env.HOME && env.HOME.length > 0 ? env.HOME : homedir();
+    const hermesHome = configured.length > 0
+        ? resolve(cwd, expandHome(configured, env, home))
+        : join(resolve(cwd, home), ".hermes");
+    if (expandHome(hermesHome, env, home) !== hermesHome)
+        throw new Error("cannot resolve HERMES_HOME: home expansion is not stable");
+    const managerRoot = join(hermesHome, "superpowers-manager");
+    const pluginsRoot = join(hermesHome, "plugins");
+    return {
+        hermesHome,
+        managerRoot,
+        preparedRoot: join(managerRoot, "prepared"),
+        pluginsRoot,
+        pluginRoot: join(pluginsRoot, "superpowers"),
+    };
+}
+export async function assertHermesStorageAncestorsSafe(paths) {
+    for (const path of [
+        paths.hermesHome,
+        paths.managerRoot,
+        paths.preparedRoot,
+        paths.pluginsRoot,
+    ])
+        await assertNoFollowType(path, ["directory", "missing"]);
+}
+export async function assertHermesStorageSafe(paths) {
+    await assertHermesStorageAncestorsSafe(paths);
+    await assertNoFollowType(paths.pluginRoot, ["directory", "missing"]);
+}

package/dist/harnesses/hermes/prepare.js

@@ -0,0 +1,78 @@
+import { readdir, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { failureResult, successResult, } from "../../adapter-result.js";
+import { readArtifactFile, validateNativeSkill } from "../../artifact-tree.js";
+import { assertNoFollowType, classifyPathNoFollow } from "../../safe-path.js";
+import { SafetyError } from "../../safety-error.js";
+import { validateSource } from "../../selection.js";
+import { createSnapshotReceipts, } from "../../snapshot-package.js";
+import { createSnapshotPreparation } from "../../snapshot-prepare.js";
+import { assertHermesStorageSafe, hermesPaths } from "./paths.js";
+async function flattenHermesPlugin(root) {
+    const nativeRoot = join(root, ".hermes-plugin");
+    if ((await classifyPathNoFollow(nativeRoot)) !== "directory")
+        return;
+    const entries = await readdir(nativeRoot);
+    if (entries.some((entry) => entry === "skills" || entry === "LICENSE"))
+        throw new SafetyError("hermes-package", `Hermes plugin layout collides with shared content: ${root}`);
+    for (const entry of await readdir(root))
+        if (entry !== ".hermes-plugin" && entry !== "skills" && entry !== "LICENSE")
+            await rm(join(root, entry), { recursive: true, force: true });
+    for (const entry of entries)
+        await rename(join(nativeRoot, entry), join(root, entry));
+    await rm(nativeRoot, { recursive: true });
+    await writeFile(join(root, "__pycache__"), "", { flag: "wx" });
+}
+async function assessHermesCompatibility(root, selection) {
+    try {
+        validateSource(selection.effectiveSource);
+        await readArtifactFile(root, join(root, "__pycache__"), 0);
+        for (const relative of [
+            "plugin.yaml",
+            "__init__.py",
+            "skills/using-superpowers/references/hermes-tools.md",
+        ])
+            await assertNoFollowType(join(root, relative), ["regular-file"]);
+        await validateNativeSkill(root);
+        return {
+            kind: "supported",
+            generation: "hermes-flat-plugin-v1",
+            reason: "native Hermes plugin",
+        };
+    }
+    catch {
+        return {
+            kind: "unsupported",
+            reason: `Hermes package does not provide a native Hermes plugin: ${root}`,
+        };
+    }
+}
+const receipts = createSnapshotReceipts({
+    harness: "hermes",
+    label: "Hermes",
+    strictGeneration: true,
+    assessCompatibility: assessHermesCompatibility,
+});
+export const readHermesReceipt = receipts.readReceipt;
+export const readHermesPackageAssessment = receipts.readAssessment;
+export async function validateHermesPreparationBeforeFetch(ctx) {
+    try {
+        await assertHermesStorageSafe(hermesPaths(ctx.env ?? {}, process.cwd()));
+        return successResult("prepare", null, []);
+    }
+    catch {
+        return failureResult("prepare", "invalid-package", "cannot validate Hermes artifact storage", [], []);
+    }
+}
+const preparation = createSnapshotPreparation({
+    harness: "hermes",
+    label: "Hermes",
+    paths: hermesPaths,
+    assessCompatibility: assessHermesCompatibility,
+    readAssessment: readHermesPackageAssessment,
+    layout: flattenHermesPlugin,
+});
+export const hermesPreparationLocation = preparation.preparationLocation;
+export const prepareHermesCandidate = preparation.prepareCandidate;
+export const inspectHermesPrepared = preparation.inspectPrepared;
+export const readHermesPrepared = preparation.readPrepared;

package/dist/harnesses/hermes/presentation.js

@@ -0,0 +1,23 @@
+import { displaySource } from "../../selection.js";
+import { createSnapshotPresentation, probeOutput, } from "../../snapshot-presentation.js";
+import { displayPath } from "../../validator.js";
+const renderProbe = (facts) => {
+    const fields = [
+        ["harness", "hermes"],
+        ["desired_commit", facts.selection.desiredCommit],
+        ["upstream_source_origin", facts.selection.upstreamSourceOrigin],
+        ["effective_source", displaySource(facts.selection.effectiveSource)],
+        ["prepared_identity", facts.prepared.observedIdentity],
+        ["installed_identity", facts.installed.observedIdentity],
+        ["installation_state", facts.installed.kind],
+        ["resource_state", facts.resourceState ?? "idle"],
+        ["ownership", facts.ownership.presentationValue],
+        ["conflicts", (facts.ownership.presentationConflicts ?? []).join("; ")],
+        ["update_control", facts.control.presentationValue],
+        ["compatibility", facts.compatibility.kind],
+        ["compatibility_reason", facts.compatibility.reason],
+        ["status", facts.status],
+    ].map(([key, value]) => [key, displayPath(value)]);
+    return probeOutput(fields);
+};
+export const hermesPresentation = createSnapshotPresentation("Hermes", renderProbe, (input) => input.ownership === "absent");

package/dist/harnesses/hermes/state.js

@@ -0,0 +1,144 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { inspectionFailure, successResult, } from "../../adapter-result.js";
+import { classifyPathNoFollow } from "../../safe-path.js";
+import { observeSnapshot, sameSnapshotSource } from "../../snapshot-package.js";
+import { displayPath } from "../../validator.js";
+import { findSuperpowersManifests, projectPluginsEnabled, readHermesStatus, } from "./observe.js";
+import { assertHermesStorageAncestorsSafe, hermesPaths, } from "./paths.js";
+import { readHermesPackageAssessment, readHermesReceipt, } from "./prepare.js";
+export async function observeHermesOwnership(paths) {
+    await assertHermesStorageAncestorsSafe(paths);
+    const snapshot = await observeSnapshot(paths.pluginRoot, readHermesReceipt);
+    return snapshot.kind === "unverified" ? { kind: "foreign" } : snapshot;
+}
+export async function otherSuperpowersManifests(paths) {
+    await assertHermesStorageAncestorsSafe(paths);
+    return (await findSuperpowersManifests(paths)).filter((root) => root !== paths.pluginRoot);
+}
+async function observeFacts(ctx) {
+    const env = ctx.env ?? {};
+    const paths = hermesPaths(env, process.cwd());
+    const ownership = await observeHermesOwnership(paths);
+    const status = await readHermesStatus(paths, env);
+    // A foreign leaf is already a blocking decision. Do not scan its contents
+    // or pass a symlink to the manifest observer.
+    const manifests = ownership.kind === "foreign" ? [] : await findSuperpowersManifests(paths);
+    return {
+        paths,
+        ownership,
+        status,
+        manifests,
+        conflicts: manifests.filter((root) => root !== paths.pluginRoot),
+    };
+}
+function blocked(...stderr) {
+    return {
+        kind: "blocked",
+        output: { stdout: [], stderr: stderr.map(displayPath) },
+    };
+}
+function installDecision(facts, env) {
+    if (facts.ownership.kind === "foreign")
+        return blocked("error: another Superpowers copy is present in Hermes; remove it manually, then retry:", "  hermes plugins remove superpowers");
+    if (facts.conflicts.length > 0)
+        return blocked("error: Hermes discovers another plugin named superpowers; remove it manually, then retry:", ...facts.conflicts.map((path) => `  ${path}`));
+    if (projectPluginsEnabled(env))
+        return blocked("error: HERMES_ENABLE_PROJECT_PLUGINS is set; a project-local Superpowers copy would override the managed one. Unset HERMES_ENABLE_PROJECT_PLUGINS, then retry.");
+    return { kind: "allowed" };
+}
+export async function inspectHermesOwnership(ctx) {
+    const operation = "inspect-hermes-ownership";
+    try {
+        const facts = await observeFacts(ctx);
+        const listed = facts.status !== "not enabled";
+        return successResult(operation, {
+            installEligibility: installDecision(facts, ctx.env ?? {}),
+            removalInput: { ownership: facts.ownership.kind, listed },
+            removalVerification: facts.ownership.kind !== "absent" || listed
+                ? blocked("error: Hermes still lists Superpowers or its plugin directory is still present after removal")
+                : { kind: "allowed" },
+            postRemovalOutput: { stdout: [], stderr: [] },
+            presentationValue: facts.ownership.kind === "owned"
+                ? `managed ${facts.ownership.digest}`
+                : facts.ownership.kind === "foreign"
+                    ? "foreign plugin directory"
+                    : "absent",
+            presentationConflicts: facts.conflicts,
+        }, []);
+    }
+    catch {
+        return inspectionFailure(operation, "Hermes ownership");
+    }
+}
+export async function inspectHermesInstalled(selection, ctx) {
+    const operation = "inspect-hermes-installed";
+    let facts;
+    try {
+        facts = await observeFacts(ctx);
+    }
+    catch {
+        return inspectionFailure(operation, "Hermes installed state");
+    }
+    if (facts.ownership.kind === "absent" &&
+        facts.status === "not enabled" &&
+        facts.manifests.length === 0)
+        return successResult(operation, { kind: "absent", observedIdentity: "" }, []);
+    const observed = facts.ownership.kind === "owned"
+        ? facts.ownership.digest
+        : facts.ownership.kind === "foreign"
+            ? "foreign plugin directory"
+            : "listed without an installed snapshot";
+    const mismatch = () => successResult(operation, { kind: "mismatch", observedIdentity: observed }, []);
+    if (facts.ownership.kind !== "owned" ||
+        facts.status !== "enabled" ||
+        !facts.manifests.includes(facts.paths.pluginRoot) ||
+        facts.conflicts.length > 0)
+        return mismatch();
+    try {
+        const prepared = await readHermesPackageAssessment(facts.paths.preparedRoot);
+        if (prepared.compatibility.kind !== "supported" ||
+            prepared.receipt.commit !== selection.desiredCommit ||
+            !sameSnapshotSource(prepared.receipt.source, selection.effectiveSource) ||
+            facts.ownership.receipt.commit !== selection.desiredCommit ||
+            !sameSnapshotSource(facts.ownership.receipt.source, selection.effectiveSource) ||
+            facts.ownership.digest !== prepared.receipt.digest)
+            return mismatch();
+    }
+    catch {
+        return mismatch();
+    }
+    return successResult(operation, { kind: "current", observedIdentity: observed }, []);
+}
+export async function leftoverHermesPublication(paths) {
+    await assertHermesStorageAncestorsSafe(paths);
+    if ((await classifyPathNoFollow(paths.managerRoot)) === "missing")
+        return [];
+    return (await readdir(paths.managerRoot))
+        .filter((name) => name.startsWith("publish."))
+        .sort()
+        .map((name) => join(paths.managerRoot, name));
+}
+export async function inspectHermesControl(ctx) {
+    const operation = "inspect-hermes-control";
+    try {
+        const paths = hermesPaths(ctx.env ?? {}, process.cwd());
+        const leftovers = await leftoverHermesPublication(paths);
+        if (leftovers.length === 0)
+            return successResult(operation, {
+                probeEligibility: { kind: "allowed" },
+                mutationEligibility: { kind: "allowed" },
+                presentationValue: "clear",
+            }, []);
+        const decision = blocked("error: Hermes recovery required; inspect and remove leftover publication material manually:", ...leftovers.map((path) => `  ${path}`));
+        return successResult(operation, {
+            probeEligibility: decision,
+            mutationEligibility: decision,
+            presentationValue: displayPath(`recovery required at ${leftovers.join(", ")}`),
+            recoveryState: "required",
+        }, []);
+    }
+    catch {
+        return inspectionFailure(operation, "Hermes update control");
+    }
+}

package/dist/snapshot-prepare.js

@@ -21,6 +21,8 @@ export function createSnapshotPreparation(b) {
         async prepareCandidate(input) {
             try {
                 await materializeGitTree(input.upstreamRoot, input.selection.desiredCommit, input.candidateRoot);
+                if (b.layout !== undefined)
+                    await b.layout(input.candidateRoot);
                 const compatibility = await b.assessCompatibility(input.candidateRoot, input.selection);
                 if (compatibility.kind === "unsupported" ||
                     compatibility.kind === "unknown")

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 };

package/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 };