@oldboydev/sheldon-darwin-arm64 0.2.1 → 0.2.2

package/node_modules/@sheldon/cli/dist/commands/memory.js

@@ -301,6 +301,35 @@ export async function compileMemory(kind, slug, proposalId, options, context, de
     options.signal?.throwIfAborted();
     context.write(JSON.stringify(result, null, 2));
 }
+export async function listPendingReviews(options, context) {
+    const root = await resolveVaultPath(context, options.vault);
+    const vault = await VaultService.discover(root);
+    const topics = [];
+    for (const entity of (await vault.listEntities('topic'))){
+        if (entity.status !== 'active') continue;
+        const store = new ProposalStore(entityDirectory(root, 'topic', entity.slug));
+        const proposals = [];
+        for (const metadata of (await store.list())){
+            if (metadata.status !== 'pending') continue;
+            const stored = await store.load(metadata.id);
+            if (stored.proposal === undefined) continue;
+            proposals.push({
+                id: metadata.id,
+                agent: metadata.agent,
+                createdAt: metadata.createdAt
+            });
+        }
+        if (proposals.length === 0) continue;
+        topics.push({
+            slug: entity.slug,
+            title: entity.title,
+            proposals
+        });
+    }
+    context.write(JSON.stringify({
+        topics
+    }));
+}
 export async function previewProposal(kind, slug, proposalId, options, context) {
     const entity = await resolveEntity(kind, slug, options.vault, context);
     const proposal = new ProposalStore(entity).assertPromotable(await new ProposalStore(entity).load(proposalId));

package/node_modules/@sheldon/cli/dist/help/pages/compile.html

@@ -107,6 +107,7 @@ sheldon compile-retry <kind> <slug> <proposal-id> --from <p
 <ul>
 <li>Agent not installed or not logged in — run <code>sheldon agent doctor</code> and complete the agent’s own login/auth flow.</li>
 <li>Raw path missing or outside <code>raw/</code> — ingest first, then pass paths relative to the entity (for example <code>raw/&lt;source-id&gt;/content.md</code>).</li>
+<li>Agent wiki files missing YAML concept frontmatter (<code>id</code>, <code>type</code>, <code>title</code>, <code>description</code>, <code>aliases</code>, <code>tags</code>, <code>created_at</code>, <code>updated_at</code>, <code>status</code>, <code>sources</code>) — compile stores <code>error</code>, not a pending proposal; retry with those fields in each page.</li>
 <li>No configured vault — pass <code>--vault &lt;path&gt;</code> or run <code>sheldon init</code>.</li>
 <li>Invalid or duplicate retry id — choose a new <code>proposal-id</code> different from <code>--from</code>.</li>
 </ul>

package/node_modules/@sheldon/cli/dist/help/pages/flow-compile-review.html

@@ -100,6 +100,7 @@ sheldon ingest file topic learning ~/inbox/article.pdf --vault ~/knowledge/sheld
 <pre><code class="language-sh">sheldon review preview topic learning proposal-article --vault ~/knowledge/sheldon
 </code></pre>
 <p>Inspect the listed file paths before applying anything.</p>
+<p>The same pending proposals appear in <code>sheldon web</code> → <strong>Revisão</strong>: choose the topic, then the proposal, then <strong>Abrir revisão</strong>. Attempts with status <code>error</code> or <code>cancelled</code> are omitted.</p>
 <h2>Approve selected paths</h2>
 <p>PowerShell:</p>
 <pre><code class="language-powershell">sheldon review approve topic learning proposal-article wiki/practical-ideas.md `

package/node_modules/@sheldon/cli/dist/help/pages/review.html

@@ -104,6 +104,7 @@ sheldon review lint topic learning
 <li>No configured vault — pass <code>--vault &lt;path&gt;</code> or run <code>sheldon init</code>.</li>
 <li>Empty <code>--reason</code> on reject — supply a non-empty reason.</li>
 </ul>
+<p>The local web UI (<code>sheldon web</code> → <strong>Revisão</strong>) lists pending proposals by topic and opens the same preview; approve still requires the confirmation token and selected paths.</p>
 <p>See <a href="flow-compile-review.html">Compile then review</a> for the end-to-end raw → approve path.</p>
 </article>
 </div>

package/node_modules/@sheldon/cli/dist/help/pages/web.html

@@ -85,14 +85,16 @@ sheldon web --vault ~/knowledge/sheldon --port 8787
 <li>Prints <code>Sheldon web: http://127.0.0.1:&lt;port&gt;</code> and a reminder that access is loopback-only.</li>
 <li>Serves the local UI until you press Ctrl+C.</li>
 <li>Does not expose the vault on the LAN or internet.</li>
+<li><strong>Revisão</strong> lists topics that currently have a pending proposal, then the pending proposals of</li>
 </ul>
+<p>the chosen topic. <strong>Abrir revisão</strong> loads the file diffs; approve still writes only the selected wiki paths. Compile from the CLI does not fill the job list — pick the proposal from those selects.</p>
 <h2>Common failures</h2>
 <ul>
 <li>No configured vault — pass <code>--vault &lt;path&gt;</code> or run <code>sheldon init</code>. Sheldon does <strong>not</strong> list vaults.</li>
 <li>Port already in use — omit <code>--port</code> for an automatic free port, or choose another value.</li>
 <li>Browser cannot reach a non-loopback URL — open the printed <code>127.0.0.1</code> address only; do not put a reverse proxy in front.</li>
 </ul>
-<p>Related: <a href="init.html">init</a>, <a href="flow-first-vault.html">First vault</a>.</p>
+<p>Related: <a href="init.html">init</a>, <a href="flow-first-vault.html">First vault</a>, <a href="review.html">review</a>, <a href="flow-compile-review.html">Compile then review</a>.</p>
 </article>
 </div>
 </div>

package/node_modules/@sheldon/cli/dist/web-api.js

@@ -1,7 +1,7 @@
 /** Public application-facing adapters shared by the local web server and the CLI. */ import { PluginSelector } from '@sheldon/plugin-host';
 import { archiveEntity, listEntities, showEntity } from './commands/entities.js';
 import { buildBundle, createBundle, validateBundle } from './commands/bundle.js';
-import { compileMemory, ingestCrawl, ingestFile, ingestRepository, ingestUrl, lintWiki, previewProposal, approveProposal } from './commands/memory.js';
+import { compileMemory, ingestCrawl, ingestFile, ingestRepository, ingestUrl, lintWiki, listPendingReviews, previewProposal, approveProposal } from './commands/memory.js';
 import { doctorPlugin } from './commands/plugins.js';
 import { queryVault } from './commands/query.js';
 import { searchVault } from './commands/search.js';
@@ -12,7 +12,7 @@ export { buildBundle, createBundle, validateBundle } from './commands/bundle.js'
 export { doctorPlugin } from './commands/plugins.js';
 export { queryVault } from './commands/query.js';
 export { searchVault } from './commands/search.js';
-export { compileMemory, ingestCrawl, ingestFile, ingestRepository, ingestUrl, previewProposal, approveProposal, lintWiki } from './commands/memory.js';
+export { compileMemory, ingestCrawl, ingestFile, ingestRepository, ingestUrl, listPendingReviews, previewProposal, approveProposal, lintWiki } from './commands/memory.js';
 export { rejectProposal } from './commands/workflow.js';
 export { withPluginServices } from './plugin-services.js';
 /** Builds the only domain-facing surface consumed by the Fastify server. */ export function createWebApplication(context, vault) {
@@ -32,6 +32,9 @@ export { withPluginServices } from './plugin-services.js';
                     project: query.project,
                     tag: query.tag
                 }, output)),
+        listPendingReviews: ()=>capture(context, (output)=>listPendingReviews({
+                    vault
+                }, output)),
         previewProposal: (kind, slug, proposalId)=>capture(context, (output)=>previewProposal(kind, slug, proposalId, {
                     vault
                 }, output)),

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/dist/adapters.js

@@ -59,6 +59,9 @@ function renderPrompt(task) {
         'You may read only these raw source files, and must cite only these paths in the response:',
         ...task.rawSources.map((source)=>`- ${source}`),
         'Do not modify files. Propose changes only under wiki/.',
+        'Each created or modified wiki file must be Markdown that starts with YAML frontmatter containing id, type, title, description, aliases, tags, created_at, updated_at, status, and sources.',
+        'created_at and updated_at must be ISO-8601 timestamps. sources must list the cited raw paths for that file.',
+        'Write a real concept body after the frontmatter; do not use placeholder text.',
         'Return the structured proposal only; do not wrap it in Markdown or add commentary.',
         'User request:',
         task.prompt

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/dist/proposal-schema.js

@@ -1,5 +1,5 @@
 import { PROPOSAL_SCHEMA_VERSION } from './proposal.js';
-export const STRUCTURED_PROPOSAL_SCHEMA_ID = 'sheldon-proposal/v1';
+export const STRUCTURED_PROPOSAL_SCHEMA_ID = 'urn:sheldon:proposal:v1';
 export const AGENT_PROMPT_VERSION = 'm2/v1';
 /**
  * The wire schema passed directly to agent CLIs. Keep this independent of the
@@ -48,7 +48,8 @@ export const AGENT_PROMPT_VERSION = 'm2/v1';
                         ]
                     },
                     content: {
-                        type: 'string'
+                        type: 'string',
+                        description: 'Markdown starting with YAML frontmatter (id, type, title, description, aliases, tags, created_at, updated_at, status, sources) then the concept body.'
                     },
                     citations: {
                         type: 'array',

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/dist/proposal-store.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { atomicWriteFile } from '@sheldon/vault';
 import { ProposalPromotionError } from './errors.js';
@@ -40,6 +40,25 @@ export class ProposalStore {
             diffs: []
         };
     }
+    async list() {
+        const root = join(resolve(this.entityDirectory), 'outputs', 'proposals');
+        let entries;
+        try {
+            entries = await readdir(root, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if (isMissing(error)) return [];
+            throw error;
+        }
+        const listed = [];
+        for (const entry of entries){
+            if (!entry.isDirectory() || !isProposalId(entry.name)) continue;
+            const metadata = await readJsonIfPresent(join(root, entry.name, 'metadata.json'));
+            if (metadata?.id === entry.name) listed.push(metadata);
+        }
+        return listed.sort((left, right)=>right.createdAt.localeCompare(left.createdAt) || left.id.localeCompare(right.id));
+    }
     async load(id) {
         this.assertId(id);
         const directory = this.directory(id);

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/dist/proposal.js

@@ -1,3 +1,4 @@
+import { parseWikiFrontmatter, wikiConceptFrontmatterIssues } from '@sheldon/core';
 import { ProposalValidationError } from './errors.js';
 export const PROPOSAL_SCHEMA_VERSION = 1;
 const maximumDiffLines = 2_000;
@@ -54,6 +55,23 @@ export function validateProposal(candidate) {
                 issues.push(`File ${file.path} cites an undeclared raw source ${citation}.`);
             }
         }
+        if (file.operation !== 'delete' && typeof file.content === 'string') {
+            const frontmatter = parseWikiFrontmatter(file.content);
+            const schemaIssues = wikiConceptFrontmatterIssues(frontmatter);
+            if (schemaIssues.length > 0) {
+                issues.push(`File ${file.path} wiki concept frontmatter is invalid: ${schemaIssues.join(' ')}`);
+            } else {
+                const conceptSources = frontmatter.sources;
+                for (const citation of file.citations ?? []){
+                    if (!conceptSources.includes(citation)) {
+                        issues.push(`File ${file.path} frontmatter must list every cited raw source.`);
+                    }
+                }
+            }
+            if (wikiBody(file.content).length === 0) {
+                issues.push(`File ${file.path} must include a concept body.`);
+            }
+        }
     }
     if (issues.length > 0) throw new ProposalValidationError(issues);
     return {
@@ -75,6 +93,9 @@ export function summarizeProposal(proposal, currentFiles = {}) {
         };
     });
 }
+function wikiBody(content) {
+    return content.replace(/^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/, '').trim();
+}
 export function isProposalId(value) {
     return /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(value);
 }

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/dist/query-answer-schema.js

@@ -1,6 +1,6 @@
 import { AGENT_PROFILE_IDS } from './profiles.js';
 import { QUERY_ANSWER_SCHEMA_VERSION } from './query-answer.js';
-export const QUERY_ANSWER_SCHEMA_ID = 'sheldon-query-answer/v1';
+export const QUERY_ANSWER_SCHEMA_ID = 'urn:sheldon:query-answer:v1';
 /** JSON Schema supplied to query adapters that need structured answer output. */ export const queryAnswerJsonSchema = {
     $schema: 'https://json-schema.org/draft/2020-12/schema',
     $id: QUERY_ANSWER_SCHEMA_ID,

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/node_modules/@sheldon/core/dist/index.js

@@ -2,3 +2,4 @@ export { archiveEntityMetadata, createEntityMetadata, renameEntityMetadata } fro
 export { slugify } from './slug.js';
 export { markdownBody } from './markdown.js';
 export { isoTimestampEpoch } from './timestamp.js';
+export { parseWikiFrontmatter, wikiConceptFrontmatterIssues, WIKI_CONCEPT_FRONTMATTER_FIELDS } from './wiki-concept.js';

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/node_modules/@sheldon/core/dist/wiki-concept.js

@@ -0,0 +1,67 @@
+import { parse } from 'yaml';
+import { isoTimestampEpoch } from './timestamp.js';
+export const WIKI_CONCEPT_FRONTMATTER_FIELDS = [
+    'id',
+    'type',
+    'title',
+    'description',
+    'aliases',
+    'tags',
+    'created_at',
+    'updated_at',
+    'status',
+    'sources'
+];
+/** Parses the leading YAML frontmatter of a wiki concept, or `{}` when it is absent or invalid. */ export function parseWikiFrontmatter(content) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(content);
+    if (!match) return {};
+    try {
+        const value = parse(match[1]);
+        return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : {};
+    } catch  {
+        return {};
+    }
+}
+/** Returns human-readable issues for M2 wiki concept frontmatter. */ export function wikiConceptFrontmatterIssues(frontmatter) {
+    const issues = [];
+    for (const field of WIKI_CONCEPT_FRONTMATTER_FIELDS){
+        if (!(field in frontmatter)) issues.push(`Missing required frontmatter field '${field}'.`);
+    }
+    if (!isNonEmptyString(frontmatter.id) || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(frontmatter.id)) {
+        issues.push("'id' must be a stable identifier.");
+    }
+    for (const field of [
+        'type',
+        'title',
+        'description',
+        'status'
+    ]){
+        if (!isNonEmptyString(frontmatter[field])) issues.push(`'${field}' must be a non-empty string.`);
+    }
+    for (const field of [
+        'aliases',
+        'tags',
+        'sources'
+    ]){
+        if (!isStringList(frontmatter[field])) issues.push(`'${field}' must be a list of non-empty strings.`);
+    }
+    if (Array.isArray(frontmatter.sources) && frontmatter.sources.length === 0) {
+        issues.push("'sources' must contain at least one raw artifact.");
+    }
+    for (const field of [
+        'created_at',
+        'updated_at'
+    ]){
+        if (!isTimestamp(frontmatter[field])) issues.push(`'${field}' must be an ISO-8601 timestamp.`);
+    }
+    return issues;
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function isStringList(value) {
+    return Array.isArray(value) && value.every(isNonEmptyString);
+}
+function isTimestamp(value) {
+    return isNonEmptyString(value) && isoTimestampEpoch(value) !== undefined;
+}

package/node_modules/@sheldon/cli/node_modules/@sheldon/agent-runtime/node_modules/@sheldon/core/package.json

@@ -5,5 +5,8 @@
   "type": "module",
   "exports": {
     ".": "./dist/index.js"
+  },
+  "dependencies": {
+    "yaml": "^2.9.0"
   }
 }

package/node_modules/@sheldon/cli/node_modules/@sheldon/core/dist/index.js

@@ -2,3 +2,4 @@ export { archiveEntityMetadata, createEntityMetadata, renameEntityMetadata } fro
 export { slugify } from './slug.js';
 export { markdownBody } from './markdown.js';
 export { isoTimestampEpoch } from './timestamp.js';
+export { parseWikiFrontmatter, wikiConceptFrontmatterIssues, WIKI_CONCEPT_FRONTMATTER_FIELDS } from './wiki-concept.js';

package/node_modules/@sheldon/cli/node_modules/@sheldon/core/dist/wiki-concept.js

@@ -0,0 +1,67 @@
+import { parse } from 'yaml';
+import { isoTimestampEpoch } from './timestamp.js';
+export const WIKI_CONCEPT_FRONTMATTER_FIELDS = [
+    'id',
+    'type',
+    'title',
+    'description',
+    'aliases',
+    'tags',
+    'created_at',
+    'updated_at',
+    'status',
+    'sources'
+];
+/** Parses the leading YAML frontmatter of a wiki concept, or `{}` when it is absent or invalid. */ export function parseWikiFrontmatter(content) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(content);
+    if (!match) return {};
+    try {
+        const value = parse(match[1]);
+        return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : {};
+    } catch  {
+        return {};
+    }
+}
+/** Returns human-readable issues for M2 wiki concept frontmatter. */ export function wikiConceptFrontmatterIssues(frontmatter) {
+    const issues = [];
+    for (const field of WIKI_CONCEPT_FRONTMATTER_FIELDS){
+        if (!(field in frontmatter)) issues.push(`Missing required frontmatter field '${field}'.`);
+    }
+    if (!isNonEmptyString(frontmatter.id) || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(frontmatter.id)) {
+        issues.push("'id' must be a stable identifier.");
+    }
+    for (const field of [
+        'type',
+        'title',
+        'description',
+        'status'
+    ]){
+        if (!isNonEmptyString(frontmatter[field])) issues.push(`'${field}' must be a non-empty string.`);
+    }
+    for (const field of [
+        'aliases',
+        'tags',
+        'sources'
+    ]){
+        if (!isStringList(frontmatter[field])) issues.push(`'${field}' must be a list of non-empty strings.`);
+    }
+    if (Array.isArray(frontmatter.sources) && frontmatter.sources.length === 0) {
+        issues.push("'sources' must contain at least one raw artifact.");
+    }
+    for (const field of [
+        'created_at',
+        'updated_at'
+    ]){
+        if (!isTimestamp(frontmatter[field])) issues.push(`'${field}' must be an ISO-8601 timestamp.`);
+    }
+    return issues;
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function isStringList(value) {
+    return Array.isArray(value) && value.every(isNonEmptyString);
+}
+function isTimestamp(value) {
+    return isNonEmptyString(value) && isoTimestampEpoch(value) !== undefined;
+}

package/node_modules/@sheldon/cli/node_modules/@sheldon/core/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/@sheldon/cli/node_modules/@sheldon/core/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/@sheldon/cli/node_modules/@sheldon/core/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 };

package/node_modules/@sheldon/cli/node_modules/@sheldon/core/node_modules/yaml/browser/dist/compose/compose-node.js

@@ -0,0 +1,109 @@
+import { Alias } from '../nodes/Alias.js';
+import { isScalar } from '../nodes/identity.js';
+import { composeCollection } from './compose-collection.js';
+import { composeScalar } from './compose-scalar.js';
+import { resolveEnd } from './resolve-end.js';
+import { emptyScalarPosition } from './util-empty-scalar-position.js';
+
+const CN = { composeNode, composeEmptyNode };
+function composeNode(ctx, token, props, onError) {
+    const atKey = ctx.atKey;
+    const { spaceBefore, comment, anchor, tag } = props;
+    let node;
+    let isSrcToken = true;
+    switch (token.type) {
+        case 'alias':
+            node = composeAlias(ctx, token, onError);
+            if (anchor || tag)
+                onError(token, 'ALIAS_PROPS', 'An alias node must not specify any properties');
+            break;
+        case 'scalar':
+        case 'single-quoted-scalar':
+        case 'double-quoted-scalar':
+        case 'block-scalar':
+            node = composeScalar(ctx, token, tag, onError);
+            if (anchor)
+                node.anchor = anchor.source.substring(1);
+            break;
+        case 'block-map':
+        case 'block-seq':
+        case 'flow-collection':
+            try {
+                node = composeCollection(CN, ctx, token, props, onError);
+                if (anchor)
+                    node.anchor = anchor.source.substring(1);
+            }
+            catch (error) {
+                // Almost certainly here due to a stack overflow
+                const message = error instanceof Error ? error.message : String(error);
+                onError(token, 'RESOURCE_EXHAUSTION', message);
+            }
+            break;
+        default: {
+            const message = token.type === 'error'
+                ? token.message
+                : `Unsupported token (type: ${token.type})`;
+            onError(token, 'UNEXPECTED_TOKEN', message);
+            isSrcToken = false;
+        }
+    }
+    node ?? (node = composeEmptyNode(ctx, token.offset, undefined, null, props, onError));
+    if (anchor && node.anchor === '')
+        onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+    if (atKey &&
+        ctx.options.stringKeys &&
+        (!isScalar(node) ||
+            typeof node.value !== 'string' ||
+            (node.tag && node.tag !== 'tag:yaml.org,2002:str'))) {
+        const msg = 'With stringKeys, all keys must be strings';
+        onError(tag ?? token, 'NON_STRING_KEY', msg);
+    }
+    if (spaceBefore)
+        node.spaceBefore = true;
+    if (comment) {
+        if (token.type === 'scalar' && token.source === '')
+            node.comment = comment;
+        else
+            node.commentBefore = comment;
+    }
+    // @ts-expect-error Type checking misses meaning of isSrcToken
+    if (ctx.options.keepSourceTokens && isSrcToken)
+        node.srcToken = token;
+    return node;
+}
+function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag, end }, onError) {
+    const token = {
+        type: 'scalar',
+        offset: emptyScalarPosition(offset, before, pos),
+        indent: -1,
+        source: ''
+    };
+    const node = composeScalar(ctx, token, tag, onError);
+    if (anchor) {
+        node.anchor = anchor.source.substring(1);
+        if (node.anchor === '')
+            onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+    }
+    if (spaceBefore)
+        node.spaceBefore = true;
+    if (comment) {
+        node.comment = comment;
+        node.range[2] = end;
+    }
+    return node;
+}
+function composeAlias({ options }, { offset, source, end }, onError) {
+    const alias = new Alias(source.substring(1));
+    if (alias.source === '')
+        onError(offset, 'BAD_ALIAS', 'Alias cannot be an empty string');
+    if (alias.source.endsWith(':'))
+        onError(offset + source.length - 1, 'BAD_ALIAS', 'Alias ending in : is ambiguous', true);
+    const valueEnd = offset + source.length;
+    const re = resolveEnd(end, valueEnd, options.strict, onError);
+    alias.range = [offset, valueEnd, re.offset];
+    if (re.comment)
+        alias.comment = re.comment;
+    return alias;
+}
+
+export { composeEmptyNode, composeNode };