@orkastery/cli 0.2.0

package/dist/worktree.js

@@ -0,0 +1,576 @@
+"use strict";
+/**
+ * `ork worktree ensure|sync|audit|release`: a worktree como RECURSO GERENCIADO (bloco B2).
+ *
+ * No Devmaster a worktree era criada na mao e conferida de memoria. Aqui ela tem ciclo de
+ * vida: o `ork` garante que existe, sincroniza quando a base andou, audita a consistencia
+ * no proprio git (nunca por self-report) e devolve o recurso ao fim.
+ *
+ * Duas regras nao negociaveis:
+ *   1. a BASE e resolvida pelo `ork` (manifesto), nunca escolhida pelo executor;
+ *   2. os artefatos da thread (prompts, ledger, claims, handoffs) ficam em
+ *      `.orkastery/threads/<id>/`, FORA da arvore, entao remover a worktree nunca
+ *      leva junto a evidencia da conducao.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dirDaWorktree = dirDaWorktree;
+exports.branchDaWorktree = branchDaWorktree;
+exports.worktreesDoGit = worktreesDoGit;
+exports.registradaNoGit = registradaNoGit;
+exports.arvoreLimpa = arvoreLimpa;
+exports.garantirWorktree = garantirWorktree;
+exports.sincronizarWorktree = sincronizarWorktree;
+exports.auditarWorktree = auditarWorktree;
+exports.textoDoAudit = textoDoAudit;
+exports.liberarWorktree = liberarWorktree;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const ledger_1 = require("./ledger");
+const leases_1 = require("./leases");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+/** Diretorio canonico da worktree de uma thread, resolvido pelo `ork`. */
+function dirDaWorktree(carregado, id) {
+    return path.resolve(carregado.raiz, carregado.manifesto.worktree.dir, id);
+}
+/** Branch canonica da worktree de uma thread. */
+function branchDaWorktree(thread) {
+    return thread.base.branch.startsWith('ork/') ? thread.base.branch : `ork/${thread.slug}`;
+}
+/** As worktrees que o git realmente conhece (`git worktree list --porcelain`). */
+function worktreesDoGit(raiz) {
+    const r = (0, util_1.exec)('git', ['worktree', 'list', '--porcelain'], raiz);
+    if (!r.ok)
+        return [];
+    const saida = [];
+    let atual = null;
+    for (const linha of r.stdout.split('\n')) {
+        if (linha.startsWith('worktree ')) {
+            if (atual)
+                saida.push(atual);
+            atual = { dir: linha.slice('worktree '.length).trim(), branch: '', head: '' };
+        }
+        else if (atual && linha.startsWith('HEAD ')) {
+            atual.head = linha.slice('HEAD '.length).trim();
+        }
+        else if (atual && linha.startsWith('branch ')) {
+            atual.branch = linha.slice('branch '.length).trim().replace(/^refs\/heads\//, '');
+        }
+    }
+    if (atual)
+        saida.push(atual);
+    return saida;
+}
+/** A worktree deste diretorio esta registrada no git? */
+function registradaNoGit(raiz, dir) {
+    return worktreesDoGit(raiz).some((w) => w.dir === dir);
+}
+/** A arvore da worktree esta limpa? `null` quando o diretorio nem e uma arvore git. */
+function arvoreLimpa(dir) {
+    const r = (0, util_1.exec)('git', ['status', '--porcelain'], dir);
+    if (!r.ok)
+        return null;
+    return r.stdout.trim() === '';
+}
+/**
+ * Garante a worktree da thread: cria se faltar, confere se ja existe.
+ *
+ * Nunca conserta sozinho uma worktree divergente: divergencia e assunto do `audit` e do
+ * `sync`, que dizem o que houve em vez de esconder.
+ */
+function garantirWorktree(carregado, id) {
+    const { raiz, manifesto } = carregado;
+    const thread = (0, thread_1.lerThread)(raiz, id);
+    const dir = thread.worktree ?? dirDaWorktree(carregado, id);
+    const branch = branchDaWorktree(thread);
+    const base = manifesto.worktree.base_branch;
+    if (fs.existsSync(dir)) {
+        if (!registradaNoGit(raiz, dir)) {
+            return {
+                ok: false,
+                criada: false,
+                dir,
+                branch,
+                base,
+                motivo: 'tree.blocked',
+                detalhe: `${dir} existe mas nao aparece em \`git worktree list\``,
+                correcao: `remova o diretorio ou registre a worktree; depois rode: ork worktree ensure ${id}`,
+            };
+        }
+        if (thread.worktree !== dir) {
+            thread.worktree = dir;
+            (0, thread_1.gravarThread)(raiz, thread);
+        }
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeGarantida, {
+            dir,
+            branch,
+            base,
+            criada: false,
+            fonte: 'git worktree list --porcelain',
+        });
+        return {
+            ok: true,
+            criada: false,
+            dir,
+            branch,
+            base,
+            motivo: null,
+            detalhe: 'a worktree da thread ja existe e o git a reconhece',
+            correcao: '',
+        };
+    }
+    // Branch da thread ja existe (worktree removida antes)? Entao reusa a branch.
+    const jaTemBranch = (0, util_1.exec)('git', ['rev-parse', '--verify', `refs/heads/${branch}`], raiz).ok;
+    const criada = (0, thread_1.criarWorktree)(carregado, id, thread.slug, {
+        branchExistente: jaTemBranch ? branch : undefined,
+    });
+    thread.worktree = criada.dir;
+    thread.base = { branch: criada.branch, commit: thread.base.commit };
+    (0, thread_1.gravarThread)(raiz, thread);
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeGarantida, {
+        dir: criada.dir,
+        branch: criada.branch,
+        base,
+        criada: true,
+        branchReusada: jaTemBranch,
+        fonte: 'git worktree list --porcelain',
+    });
+    return {
+        ok: true,
+        criada: true,
+        dir: criada.dir,
+        branch: criada.branch,
+        base,
+        motivo: null,
+        detalhe: jaTemBranch
+            ? `worktree recriada sobre a branch ${criada.branch}, que ja existia`
+            : `worktree criada a partir de ${base}`,
+        correcao: '',
+    };
+}
+/**
+ * Sincroniza a branch da thread com a base ATUAL (rebase), quando a base avancou.
+ *
+ * A pergunta "a base avancou?" e respondida pelo git (`merge-base --is-ancestor`), nao
+ * pela data de criacao da thread: e o mesmo criterio que o `audit` usa.
+ */
+function sincronizarWorktree(carregado, id, opcoes = {}) {
+    const { raiz, manifesto } = carregado;
+    const thread = (0, thread_1.lerThread)(raiz, id);
+    const base = manifesto.worktree.base_branch;
+    const dir = thread.worktree ?? dirDaWorktree(carregado, id);
+    const branch = branchDaWorktree(thread);
+    const passos = [];
+    const vazio = {
+        dir,
+        branch,
+        base,
+        shaBase: '',
+        shaAntes: '',
+        shaDepois: '',
+        passos,
+        dryRun: opcoes.dryRun === true,
+    };
+    if (!fs.existsSync(dir) || !registradaNoGit(raiz, dir)) {
+        return {
+            ...vazio,
+            ok: false,
+            jaAtualizada: false,
+            rebaseFeito: false,
+            motivo: 'tree.blocked',
+            detalhe: `a thread ${id} nao tem worktree registrada no git`,
+            correcao: `crie a worktree com: ork worktree ensure ${id}`,
+        };
+    }
+    const limpa = arvoreLimpa(dir);
+    if (limpa !== true) {
+        return {
+            ...vazio,
+            ok: false,
+            jaAtualizada: false,
+            rebaseFeito: false,
+            motivo: 'tree.blocked',
+            detalhe: limpa === null
+                ? `${dir} nao respondeu a \`git status\``
+                : `${dir} tem alteracao nao commitada; rebase em arvore suja perde trabalho`,
+            correcao: `commite ou guarde as alteracoes em ${dir} e rode de novo: ork worktree sync ${id}`,
+        };
+    }
+    const refBase = (0, util_1.exec)('git', ['rev-parse', '--verify', base], raiz);
+    if (!refBase.ok) {
+        return {
+            ...vazio,
+            ok: false,
+            jaAtualizada: false,
+            rebaseFeito: false,
+            motivo: 'tree.blocked',
+            detalhe: `a base ${base} do manifesto nao existe neste repositorio`,
+            correcao: `corrija worktree.base_branch em ${carregado.caminho}`,
+        };
+    }
+    const shaBase = refBase.stdout.trim();
+    const shaAntes = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], dir).stdout.trim();
+    passos.push(`git rev-parse --verify ${base}   (${shaBase.slice(0, 8)})`);
+    const jaTem = (0, util_1.exec)('git', ['merge-base', '--is-ancestor', shaBase, 'HEAD'], dir).ok;
+    passos.push(`git merge-base --is-ancestor ${shaBase.slice(0, 8)} HEAD`);
+    if (jaTem) {
+        if (!opcoes.dryRun) {
+            (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada, {
+                dir,
+                branch,
+                base,
+                shaBase,
+                shaAntes,
+                shaDepois: shaAntes,
+                rebaseFeito: false,
+                detalhe: 'a base ja era ancestral do HEAD da thread',
+            });
+        }
+        return {
+            ...vazio,
+            shaBase,
+            shaAntes,
+            shaDepois: shaAntes,
+            ok: true,
+            jaAtualizada: true,
+            rebaseFeito: false,
+            motivo: null,
+            detalhe: `a base ${base} ja esta incorporada: nada a sincronizar`,
+            correcao: '',
+        };
+    }
+    if (opcoes.dryRun) {
+        passos.push(`git rebase ${shaBase}`);
+        return {
+            ...vazio,
+            shaBase,
+            shaAntes,
+            shaDepois: shaAntes,
+            ok: true,
+            jaAtualizada: false,
+            rebaseFeito: false,
+            motivo: null,
+            detalhe: `a base ${base} avancou; o sync real faria o rebase acima`,
+            correcao: '',
+        };
+    }
+    const rebase = (0, util_1.exec)('git', ['rebase', shaBase], dir);
+    passos.push(`git rebase ${shaBase}`);
+    if (!rebase.ok) {
+        (0, util_1.exec)('git', ['rebase', '--abort'], dir);
+        passos.push('git rebase --abort');
+        const detalhe = (rebase.stderr || rebase.stdout).trim().split('\n').slice(-4).join(' | ');
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada, {
+            dir,
+            branch,
+            base,
+            shaBase,
+            shaAntes,
+            rebaseFeito: false,
+            motivo: 'tree.blocked',
+            detalhe,
+        });
+        return {
+            ...vazio,
+            shaBase,
+            shaAntes,
+            shaDepois: shaAntes,
+            ok: false,
+            jaAtualizada: false,
+            rebaseFeito: false,
+            motivo: 'tree.blocked',
+            detalhe: `o rebase sobre ${base} conflitou e foi abortado: ${detalhe}`,
+            correcao: `resolva o conflito na worktree ${dir} (git rebase ${shaBase} e resolucao manual), ` +
+                `ou reduza a regiao da thread com um lease path:<glob> menor`,
+        };
+    }
+    const shaDepois = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], dir).stdout.trim();
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada, {
+        dir,
+        branch,
+        base,
+        shaBase,
+        shaAntes,
+        shaDepois,
+        rebaseFeito: true,
+        detalhe: `branch da thread rebasada sobre ${base}`,
+    });
+    return {
+        ...vazio,
+        shaBase,
+        shaAntes,
+        shaDepois,
+        ok: true,
+        jaAtualizada: false,
+        rebaseFeito: true,
+        motivo: null,
+        detalhe: `a base ${base} avancou e a branch ${branch} foi rebasada sobre ela`,
+        correcao: '',
+    };
+}
+/**
+ * Confere a consistencia da worktree NO PROPRIO GIT.
+ *
+ * Cada check responde uma pergunta que ja causou incidente no Devmaster: a worktree
+ * existe mesmo? o git a conhece? a branch em check-out e a da thread? a arvore esta
+ * limpa? a base avancou? os artefatos da thread estao fora da arvore?
+ */
+function auditarWorktree(carregado, id) {
+    const { raiz, manifesto } = carregado;
+    const thread = (0, thread_1.lerThread)(raiz, id);
+    const dir = thread.worktree ?? dirDaWorktree(carregado, id);
+    const branchEsperada = branchDaWorktree(thread);
+    const checks = [];
+    checks.push(thread.worktree
+        ? { nome: 'registro', nivel: 'ok', detalhe: `thread.json aponta para ${thread.worktree}` }
+        : {
+            nome: 'registro',
+            nivel: 'fail',
+            detalhe: 'a thread nao tem worktree registrada no thread.json',
+            correcao: `ork worktree ensure ${id}`,
+        });
+    const existe = fs.existsSync(dir);
+    checks.push(existe
+        ? { nome: 'diretorio', nivel: 'ok', detalhe: dir }
+        : {
+            nome: 'diretorio',
+            nivel: 'fail',
+            detalhe: `${dir} nao existe no disco`,
+            correcao: `ork worktree ensure ${id}`,
+        });
+    const registro = worktreesDoGit(raiz).find((w) => w.dir === dir);
+    checks.push(registro
+        ? { nome: 'git', nivel: 'ok', detalhe: 'aparece em `git worktree list --porcelain`' }
+        : {
+            nome: 'git',
+            nivel: 'fail',
+            detalhe: `${dir} nao aparece em \`git worktree list\``,
+            correcao: `git worktree prune && ork worktree ensure ${id}`,
+        });
+    if (registro) {
+        checks.push(registro.branch === branchEsperada
+            ? { nome: 'branch', nivel: 'ok', detalhe: `${registro.branch} em check-out` }
+            : {
+                nome: 'branch',
+                nivel: 'fail',
+                detalhe: `esperado ${branchEsperada}, encontrado "${registro.branch || '(HEAD solto)'}"`,
+                correcao: `git -C ${dir} switch ${branchEsperada}`,
+            });
+    }
+    if (existe) {
+        const limpa = arvoreLimpa(dir);
+        checks.push(limpa === true
+            ? { nome: 'arvore', nivel: 'ok', detalhe: 'sem alteracao nao commitada' }
+            : {
+                nome: 'arvore',
+                nivel: limpa === null ? 'fail' : 'warn',
+                detalhe: limpa === null
+                    ? '`git status` nao respondeu neste diretorio'
+                    : 'ha alteracao nao commitada na worktree',
+                correcao: `git -C ${dir} status`,
+            });
+        const base = manifesto.worktree.base_branch;
+        const refBase = (0, util_1.exec)('git', ['rev-parse', '--verify', base], raiz);
+        if (refBase.ok) {
+            const shaBase = refBase.stdout.trim();
+            const incorporada = (0, util_1.exec)('git', ['merge-base', '--is-ancestor', shaBase, 'HEAD'], dir).ok;
+            checks.push(incorporada
+                ? { nome: 'base', nivel: 'ok', detalhe: `${base} @ ${shaBase.slice(0, 8)} ja incorporada` }
+                : {
+                    nome: 'base',
+                    nivel: 'fail',
+                    detalhe: `a base ${base} avancou para ${shaBase.slice(0, 8)} e nao esta na branch da thread`,
+                    correcao: `ork worktree sync ${id}`,
+                });
+        }
+    }
+    const dirArtefatos = (0, thread_1.dirThread)(raiz, id);
+    const dentroDaArvore = path.resolve(dirArtefatos).startsWith(path.resolve(dir) + path.sep);
+    checks.push(dentroDaArvore
+        ? {
+            nome: 'artefatos',
+            nivel: 'fail',
+            detalhe: `os artefatos da thread estao DENTRO da worktree (${dirArtefatos})`,
+            correcao: 'os artefatos da thread vivem em .orkastery/threads/<id>, fora da arvore',
+        }
+        : {
+            nome: 'artefatos',
+            nivel: 'ok',
+            detalhe: `${path.relative(raiz, dirArtefatos)} fica fora da worktree`,
+        });
+    const divergencias = checks.filter((c) => c.nivel === 'fail').length;
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeAuditada, {
+        dir,
+        branch: branchEsperada,
+        divergencias,
+        checks: checks.map((c) => ({ nome: c.nome, nivel: c.nivel, detalhe: c.detalhe })),
+        fonte: 'git worktree list --porcelain, git status, git merge-base',
+    });
+    return { ok: divergencias === 0, divergencias, dir, branch: branchEsperada, checks };
+}
+/** Texto de `ork worktree audit`. */
+function textoDoAudit(id, r) {
+    const linhas = [
+        `Auditoria da worktree da thread ${id}`,
+        `  dir     ${r.dir}`,
+        `  branch  ${r.branch}`,
+        '',
+    ];
+    for (const c of r.checks) {
+        linhas.push(`  ${(0, util_1.simbolo)(c.nivel)} ${c.nome.padEnd(11)} ${c.detalhe}`);
+        if (c.nivel !== 'ok' && c.correcao)
+            linhas.push(`         correcao: ${c.correcao}`);
+    }
+    linhas.push('');
+    linhas.push(r.ok
+        ? '  worktree consistente: o git confirma cada item acima.'
+        : `  ${r.divergencias} divergencia(s) encontrada(s) no proprio git.`);
+    return linhas.join('\n');
+}
+/** Solta os leases de escrita que a thread ainda segurava. */
+function soltarLeasesDaThread(raiz, id) {
+    const soltos = [];
+    const escrita = (0, leases_1.nomeDeLease)('worktree-write', id);
+    for (const lease of (0, leases_1.leasesDaThread)(raiz, id)) {
+        if (lease.nome !== escrita)
+            continue;
+        const r = (0, leases_1.liberar)(raiz, lease.nome, id);
+        if (r.ok)
+            soltos.push(lease.nome);
+    }
+    return soltos;
+}
+/**
+ * Devolve o recurso: remove a worktree da thread e limpa o registro.
+ *
+ * Recusa arvore suja sem `--forcar`: apagar trabalho nao commitado de outra sessao e
+ * irreversivel, e o `ork` nao faz passo irreversivel por conta propria.
+ */
+function liberarWorktree(carregado, id, opcoes = {}) {
+    const { raiz } = carregado;
+    const thread = (0, thread_1.lerThread)(raiz, id);
+    const dir = thread.worktree ?? dirDaWorktree(carregado, id);
+    const branch = branchDaWorktree(thread);
+    if (!fs.existsSync(dir)) {
+        (0, util_1.exec)('git', ['worktree', 'prune'], raiz);
+        const soltos = soltarLeasesDaThread(raiz, id);
+        if (thread.worktree) {
+            thread.worktree = null;
+            (0, thread_1.gravarThread)(raiz, thread);
+        }
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeLiberada, {
+            dir,
+            branch,
+            removida: false,
+            leasesLiberados: soltos,
+            detalhe: 'o diretorio ja nao existia; o registro foi limpo',
+        });
+        return {
+            ok: true,
+            removida: false,
+            dir,
+            branch,
+            leasesLiberados: soltos,
+            motivo: null,
+            detalhe: 'o diretorio ja nao existia; registro limpo e `git worktree prune` rodado',
+            correcao: '',
+        };
+    }
+    const limpa = arvoreLimpa(dir);
+    if (limpa === false && !opcoes.forcar) {
+        return {
+            ok: false,
+            removida: false,
+            dir,
+            branch,
+            leasesLiberados: [],
+            motivo: 'tree.blocked',
+            detalhe: `${dir} tem alteracao nao commitada`,
+            correcao: `commite o que interessa em ${dir}, ou repita com --forcar para descartar`,
+        };
+    }
+    const argumentos = ['worktree', 'remove', dir];
+    if (opcoes.forcar)
+        argumentos.push('--force');
+    const r = (0, util_1.exec)('git', argumentos, raiz);
+    if (!r.ok) {
+        return {
+            ok: false,
+            removida: false,
+            dir,
+            branch,
+            leasesLiberados: [],
+            motivo: 'tree.blocked',
+            detalhe: `git worktree remove falhou: ${(r.stderr || r.stdout).trim()}`,
+            correcao: `rode \`git worktree remove ${dir}\` na mao e confira \`git worktree list\``,
+        };
+    }
+    (0, util_1.exec)('git', ['worktree', 'prune'], raiz);
+    // Prova no git, nao no codigo de saida: a worktree sumiu mesmo da lista?
+    if (registradaNoGit(raiz, dir)) {
+        return {
+            ok: false,
+            removida: false,
+            dir,
+            branch,
+            leasesLiberados: [],
+            motivo: 'tree.blocked',
+            detalhe: `${dir} continua em \`git worktree list\` depois do remove`,
+            correcao: 'git worktree prune && git worktree list',
+        };
+    }
+    const soltos = soltarLeasesDaThread(raiz, id);
+    thread.worktree = null;
+    (0, thread_1.gravarThread)(raiz, thread);
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeLiberada, {
+        dir,
+        branch,
+        removida: true,
+        forcado: opcoes.forcar === true,
+        leasesLiberados: soltos,
+        fonte: 'git worktree list --porcelain',
+    });
+    return {
+        ok: true,
+        removida: true,
+        dir,
+        branch,
+        leasesLiberados: soltos,
+        motivo: null,
+        detalhe: `worktree removida; a branch ${branch} continua no repositorio`,
+        correcao: '',
+    };
+}

package/dist/yaml.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Leitor de YAML do subconjunto que o `orkastery.yaml` usa.
+ *
+ * Deliberadamente pequeno e sem dependencia externa: mapas aninhados por indentacao
+ * de 2 espacos, listas em bloco (`- item`) e listas inline (`[a, b]`), escalares
+ * string/numero/booleano/nulo, comentarios com `#`. Qualquer construcao fora disso
+ * levanta erro com numero de linha, em vez de adivinhar.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escalar = escalar;
+exports.lerYaml = lerYaml;
+function tirarComentario(linha) {
+    let dentroDeAspas = null;
+    for (let i = 0; i < linha.length; i++) {
+        const c = linha[i];
+        if (dentroDeAspas) {
+            if (c === dentroDeAspas)
+                dentroDeAspas = null;
+        }
+        else if (c === '"' || c === "'") {
+            dentroDeAspas = c;
+        }
+        else if (c === '#' && (i === 0 || /\s/.test(linha[i - 1]))) {
+            return linha.slice(0, i);
+        }
+    }
+    return linha;
+}
+/** Converte um escalar YAML para o tipo JavaScript correspondente. */
+function escalar(bruto) {
+    const t = bruto.trim();
+    if (t === '' || t === '~' || t === 'null')
+        return null;
+    if (t === 'true' || t === 'yes')
+        return true;
+    if (t === 'false' || t === 'no')
+        return false;
+    if (/^-?\d+$/.test(t))
+        return Number(t);
+    if (/^-?\d*\.\d+$/.test(t))
+        return Number(t);
+    if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
+        return t.slice(1, -1);
+    }
+    if (t.startsWith('[') && t.endsWith(']')) {
+        const dentro = t.slice(1, -1).trim();
+        if (dentro === '')
+            return [];
+        return dentro.split(',').map((item) => escalar(item));
+    }
+    return t;
+}
+function preparar(texto) {
+    const linhas = [];
+    texto.split('\n').forEach((original, i) => {
+        const semComentario = tirarComentario(original).replace(/\s+$/, '');
+        if (semComentario.trim() === '')
+            return;
+        if (semComentario.trim() === '---')
+            return;
+        const indent = semComentario.length - semComentario.trimStart().length;
+        linhas.push({ numero: i + 1, indent, conteudo: semComentario.trim() });
+    });
+    return linhas;
+}
+function parseBloco(linhas, inicio, indent) {
+    let i = inicio;
+    if (i >= linhas.length)
+        return [null, i];
+    if (linhas[i].conteudo.startsWith('- ') || linhas[i].conteudo === '-') {
+        const lista = [];
+        while (i < linhas.length && linhas[i].indent === indent && linhas[i].conteudo.startsWith('-')) {
+            const resto = linhas[i].conteudo.slice(1).trim();
+            lista.push(escalar(resto));
+            i++;
+        }
+        return [lista, i];
+    }
+    const mapa = {};
+    while (i < linhas.length && linhas[i].indent === indent) {
+        const linha = linhas[i];
+        const sep = linha.conteudo.indexOf(':');
+        if (sep < 0) {
+            throw new Error(`YAML invalido na linha ${linha.numero}: esperado "chave: valor"`);
+        }
+        const chave = linha.conteudo.slice(0, sep).trim().replace(/^["']|["']$/g, '');
+        const resto = linha.conteudo.slice(sep + 1).trim();
+        i++;
+        if (resto !== '') {
+            mapa[chave] = escalar(resto);
+            continue;
+        }
+        if (i < linhas.length && linhas[i].indent > indent) {
+            const [filho, proximo] = parseBloco(linhas, i, linhas[i].indent);
+            mapa[chave] = filho;
+            i = proximo;
+        }
+        else {
+            mapa[chave] = null;
+        }
+    }
+    return [mapa, i];
+}
+/** Le um documento YAML do subconjunto suportado. */
+function lerYaml(texto) {
+    const linhas = preparar(texto);
+    if (linhas.length === 0)
+        return {};
+    const [valor] = parseBloco(linhas, 0, linhas[0].indent);
+    return valor;
+}