@baruk/core 0.4.2 → 0.5.0

package/dist/fiscal/repository.d.ts

@@ -0,0 +1,220 @@
+import type { Tx } from '../db/client.js';
+import type { FiscalProfile } from './conditions.js';
+import type { ClientJurisdiction, FiscalRuleRef, RuleStatus } from './applicability.js';
+/** Um atributo do vocabulário global. */
+export interface FiscalAttributeDefinition {
+    key: string;
+    label: string;
+    description: string | null;
+    valueType: 'boolean' | 'text' | 'enum';
+    allowedValues: string[] | null;
+}
+export declare function listFiscalAttributes(tx: Tx): Promise<FiscalAttributeDefinition[]>;
+export declare class UnknownFiscalAttribute extends Error {
+    constructor(key: string);
+}
+export declare class InvalidAttributeValue extends Error {
+    constructor(message: string);
+}
+/**
+ * Grava um atributo do perfil.
+ *
+ * Valida o valor CONTRA A DEFINIÇÃO antes de gravar: booleano recebe booleano,
+ * enum recebe um dos valores declarados. Sem isso, `activity_segment` aceitaria
+ * "industria " com espaço e a regra que compara com "industria" nunca casaria —
+ * e ninguém saberia por quê, porque o dado *parece* certo na tela.
+ */
+export declare function setClientFiscalAttribute(tx: Tx, input: {
+    clientId: string;
+    attributeKey: string;
+    value: string | boolean;
+    source?: string | null;
+    actorId?: string | null;
+}): Promise<void>;
+/**
+ * Remove um atributo — devolvendo-o ao estado DESCONHECIDO.
+ *
+ * Existe porque "não sei mais" é um estado legítimo e diferente de `false`.
+ * Sem esta operação, corrigir um dado errado exigiria gravar um valor que
+ * ninguém confirmou.
+ */
+export declare function clearClientFiscalAttribute(tx: Tx, input: {
+    clientId: string;
+    attributeKey: string;
+}): Promise<void>;
+/**
+ * O perfil como o motor o enxerga.
+ *
+ * Atributo ausente simplesmente não aparece no objeto — e é assim que
+ * `evaluate` o distingue de `false`.
+ */
+export declare function loadFiscalProfile(tx: Tx, clientId: string): Promise<FiscalProfile>;
+export declare function loadClientJurisdiction(tx: Tx, clientId: string): Promise<ClientJurisdiction>;
+/**
+ * As regras candidatas para um tipo de item numa competência.
+ *
+ * **Pré-filtra por jurisdição e vigência no banco**, antes de qualquer
+ * avaliação de condição. Avaliar a AST de todas as regras do país para cada
+ * cliente seria o desenho ingênuo que a premissa pede para evitar; aqui o
+ * índice `fiscal_rule_lookup_idx` reduz o conjunto a um punhado antes de o
+ * motor tocar nele.
+ *
+ * A regra do ESCRITÓRIO tem precedência sobre a global na mesma jurisdição —
+ * `DISTINCT ON` com `tenant_id NULLS LAST`, o mesmo padrão de
+ * `recurring_item_type`.
+ */
+export declare function candidateRules(tx: Tx, input: {
+    itemTypeId: string;
+    jurisdiction: ClientJurisdiction;
+    referenceDate: string;
+}): Promise<FiscalRuleRef[]>;
+/**
+ * A regra mais específica que alcança o cliente.
+ *
+ * Municipal vence estadual, que vence federal. Um município que legisla sobre
+ * a obrigação está mais perto do fato que a União.
+ */
+export declare function resolveRule(tx: Tx, input: {
+    itemTypeId: string;
+    jurisdiction: ClientJurisdiction;
+    referenceDate: string;
+}): Promise<FiscalRuleRef | null>;
+export interface CreateRuleInput {
+    itemTypeId: string;
+    jurisdictionScope: 'federal' | 'state' | 'municipal';
+    jurisdictionUf?: string | null;
+    jurisdictionCityIbge?: string | null;
+    validFrom: string;
+    validUntil?: string | null;
+    status?: RuleStatus;
+    conditions?: unknown;
+    dueRule?: Record<string, unknown> | null;
+    sourceReference?: string | null;
+    note?: string | null;
+    /** `null` cria regra GLOBAL — só o caminho de provisionamento consegue. */
+    tenantId?: string | null;
+    version?: number;
+    /**
+     * Quem conferiu. **Obrigatório quando `status` é `validated`.**
+     *
+     * Junto no INSERT, e não num UPDATE depois: o CHECK do banco recusa uma
+     * regra validada sem autor, e com razão — "está conferida" sem "por quem"
+     * é afirmação que ninguém assina. Exigir aqui move a recusa para a chamada,
+     * onde há contexto para corrigi-la.
+     */
+    validatedBy?: string | null;
+}
+/**
+ * Cria uma regra.
+ *
+ * A condição é validada AQUI, na escrita. Gravar uma AST malformada seria
+ * empurrar o erro para a madrugada da geração, onde a única saída seria não
+ * gerar sem explicar.
+ */
+export declare function createFiscalRule(tx: Tx, input: CreateRuleInput): Promise<FiscalRuleRef>;
+/**
+ * Publica uma nova versão, encerrando a anterior.
+ *
+ * **Não altera a versão antiga.** Ela recebe `valid_until` e continua lá,
+ * inteira: é ela que explica as obrigações já geradas. Editar a regra vigente
+ * em vez de versioná-la é como a mudança de amanhã reescreve o vencimento de
+ * ontem — e ninguém consegue mais dizer por que aquela data foi aquela.
+ */
+export declare function supersedeFiscalRule(tx: Tx, input: {
+    currentRuleId: string;
+    validFrom: string;
+    changes: Partial<CreateRuleInput>;
+}): Promise<{
+    previous: FiscalRuleRef;
+    next: FiscalRuleRef;
+}>;
+export declare function getFiscalRule(tx: Tx, id: string): Promise<FiscalRuleRef | null>;
+/** Prazo interno do escritório, ao lado do legal. */
+export interface TenantRulePolicy {
+    itemTypeId: string;
+    internalLeadDays: number | null;
+    enabled: boolean;
+    note: string | null;
+}
+export declare function setTenantRulePolicy(tx: Tx, input: {
+    itemTypeId: string;
+    internalLeadDays?: number | null;
+    enabled?: boolean;
+    note?: string | null;
+    actorId?: string | null;
+}): Promise<void>;
+export declare function listTenantRulePolicies(tx: Tx): Promise<TenantRulePolicy[]>;
+export interface GovernanceRule {
+    id: string;
+    itemTypeId: string;
+    itemTypeKey: string;
+    itemTypeLabel: string;
+    sphere: string;
+    origin: 'global' | 'tenant';
+    jurisdiction: {
+        scope: string;
+        uf: string | null;
+        cityIbge: string | null;
+    };
+    version: number;
+    validFrom: string;
+    validUntil: string | null;
+    status: string;
+    sourceReference: string | null;
+    sourceUrl: string | null;
+    validatedAt: string | null;
+    validatedByName: string | null;
+    note: string | null;
+    /** A tela só oferece ação no que o escritório pode de fato alterar. */
+    editable: boolean;
+}
+export interface GovernanceSummary {
+    total: number;
+    byStatus: Record<string, number>;
+    withSource: number;
+    withoutSource: number;
+    /** Pendentes que já têm fonte anexada — a fila realmente pronta para revisão. */
+    readyForHumanReview: number;
+}
+/**
+ * A fila inteira: global e do escritório, com a procedência de cada linha.
+ *
+ * Sem filtro de vigência nem de jurisdição, ao contrário de `candidateRules` —
+ * são perguntas diferentes. Aquela responde "qual regra vale para este cliente
+ * hoje"; esta responde "o que existe e o que ainda não foi conferido", e uma
+ * regra vencida ou de outra UF continua sendo trabalho de governança.
+ */
+export declare function listGovernanceRules(tx: Tx): Promise<GovernanceRule[]>;
+export declare function summarizeGovernance(rules: readonly GovernanceRule[]): GovernanceSummary;
+/**
+ * Registra a fonte e a observação de uma regra DO ESCRITÓRIO.
+ *
+ * Separado de validar de propósito: anexar evidência é preparação, e quem
+ * prepara não carimba. Não toca em `status`.
+ */
+export declare function annotateFiscalRule(tx: Tx, input: {
+    id: string;
+    sourceUrl?: string | null;
+    sourceReference?: string | null;
+    note?: string | null;
+}): Promise<void>;
+/**
+ * O carimbo humano de conferência.
+ *
+ * Três guardas, e nenhum é redundante:
+ *
+ * 1. **Só regra do escritório.** A global é do produto; conferi-la para todo o
+ *    Brasil não é decisão de um tenant.
+ * 2. **`validatedBy` obrigatório e vindo da SESSÃO**, nunca do corpo. Uma regra
+ *    validada precisa responder "quem conferiu" com um nome que a pessoa não
+ *    escolheu para si.
+ * 3. **Fonte obrigatória.** Validar sem apontar a norma é registrar uma opinião
+ *    com aparência de conferência — e é exatamente o que a trilha não deve
+ *    permitir que se pareça com evidência depois.
+ */
+export declare function validateFiscalRule(tx: Tx, input: {
+    id: string;
+    validatedBy: string;
+    note?: string | null;
+}): Promise<void>;
+//# sourceMappingURL=repository.d.ts.map

package/dist/fiscal/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../src/fiscal/repository.ts"],"names":[],"mappings":"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"}

package/dist/fiscal/repository.js

@@ -0,0 +1,449 @@
+import { uuidv7, ValidationError } from '@baruk/shared';
+import { parseCondition } from './conditions.js';
+export async function listFiscalAttributes(tx) {
+    const rows = await tx `
+    SELECT key, label, description, value_type, allowed_values
+      FROM fiscal_attribute_definition ORDER BY key
+  `;
+    return rows.map((r) => ({
+        key: r.key,
+        label: r.label,
+        description: r.description,
+        valueType: r.value_type,
+        allowedValues: Array.isArray(r.allowed_values) ? r.allowed_values : null,
+    }));
+}
+export class UnknownFiscalAttribute extends Error {
+    constructor(key) {
+        super(`Atributo fiscal desconhecido: ${key}`);
+        this.name = 'UnknownFiscalAttribute';
+    }
+}
+export class InvalidAttributeValue extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidAttributeValue';
+    }
+}
+/**
+ * Grava um atributo do perfil.
+ *
+ * Valida o valor CONTRA A DEFINIÇÃO antes de gravar: booleano recebe booleano,
+ * enum recebe um dos valores declarados. Sem isso, `activity_segment` aceitaria
+ * "industria " com espaço e a regra que compara com "industria" nunca casaria —
+ * e ninguém saberia por quê, porque o dado *parece* certo na tela.
+ */
+export async function setClientFiscalAttribute(tx, input) {
+    const [def] = await tx `
+    SELECT value_type, allowed_values FROM fiscal_attribute_definition WHERE key = ${input.attributeKey}
+  `;
+    if (!def)
+        throw new UnknownFiscalAttribute(input.attributeKey);
+    let vBool = null;
+    let vText = null;
+    if (def.value_type === 'boolean') {
+        if (typeof input.value !== 'boolean') {
+            throw new InvalidAttributeValue(`"${input.attributeKey}" espera verdadeiro ou falso.`);
+        }
+        vBool = input.value;
+    }
+    else {
+        if (typeof input.value !== 'string' || input.value.trim() === '') {
+            throw new InvalidAttributeValue(`"${input.attributeKey}" espera texto não vazio.`);
+        }
+        vText = input.value.trim();
+        if (def.value_type === 'enum') {
+            const permitidos = Array.isArray(def.allowed_values) ? def.allowed_values : [];
+            if (!permitidos.includes(vText)) {
+                throw new InvalidAttributeValue(`"${vText}" não é aceito em "${input.attributeKey}". Valores: ${permitidos.join(', ')}.`);
+            }
+        }
+    }
+    await tx `
+    INSERT INTO client_fiscal_attribute
+      (id, tenant_id, client_id, attribute_key, value_bool, value_text, source, updated_by)
+    VALUES (
+      ${uuidv7()}, current_setting('app.current_tenant')::uuid, ${input.clientId},
+      ${input.attributeKey}, ${vBool}, ${vText}, ${input.source ?? null}, ${input.actorId ?? null}
+    )
+    ON CONFLICT (tenant_id, client_id, attribute_key) DO UPDATE SET
+      value_bool = EXCLUDED.value_bool,
+      value_text = EXCLUDED.value_text,
+      source = EXCLUDED.source,
+      updated_by = EXCLUDED.updated_by,
+      updated_at = now()
+  `;
+}
+/**
+ * Remove um atributo — devolvendo-o ao estado DESCONHECIDO.
+ *
+ * Existe porque "não sei mais" é um estado legítimo e diferente de `false`.
+ * Sem esta operação, corrigir um dado errado exigiria gravar um valor que
+ * ninguém confirmou.
+ */
+export async function clearClientFiscalAttribute(tx, input) {
+    await tx `
+    DELETE FROM client_fiscal_attribute
+     WHERE client_id = ${input.clientId} AND attribute_key = ${input.attributeKey}
+  `;
+}
+/**
+ * O perfil como o motor o enxerga.
+ *
+ * Atributo ausente simplesmente não aparece no objeto — e é assim que
+ * `evaluate` o distingue de `false`.
+ */
+export async function loadFiscalProfile(tx, clientId) {
+    const rows = await tx `
+    SELECT attribute_key, value_bool, value_text
+      FROM client_fiscal_attribute WHERE client_id = ${clientId}
+  `;
+    const perfil = {};
+    for (const r of rows) {
+        perfil[r.attribute_key] = r.value_bool !== null ? r.value_bool : r.value_text;
+    }
+    return perfil;
+}
+export async function loadClientJurisdiction(tx, clientId) {
+    const [r] = await tx `
+    SELECT state_uf, municipality_ibge_code FROM client WHERE id = ${clientId} AND deleted_at IS NULL
+  `;
+    return { uf: r?.state_uf ?? null, cityIbge: r?.municipality_ibge_code ?? null };
+}
+const iso = (d) => d.toISOString().slice(0, 10);
+const mapRule = (r) => ({
+    id: r.id,
+    tenantId: r.tenant_id,
+    itemTypeId: r.item_type_id,
+    version: r.version,
+    jurisdiction: {
+        scope: r.jurisdiction_scope,
+        uf: r.jurisdiction_uf,
+        cityIbge: r.jurisdiction_city_ibge,
+    },
+    validFrom: iso(r.valid_from),
+    validUntil: r.valid_until ? iso(r.valid_until) : null,
+    status: r.status,
+    conditions: r.conditions ?? { op: 'always' },
+    dueRule: r.due_rule,
+    sourceReference: r.source_reference,
+});
+const RULE_COLS = `
+  id, tenant_id, item_type_id, version, jurisdiction_scope, jurisdiction_uf,
+  jurisdiction_city_ibge, valid_from, valid_until, status, conditions, due_rule, source_reference
+`;
+/**
+ * As regras candidatas para um tipo de item numa competência.
+ *
+ * **Pré-filtra por jurisdição e vigência no banco**, antes de qualquer
+ * avaliação de condição. Avaliar a AST de todas as regras do país para cada
+ * cliente seria o desenho ingênuo que a premissa pede para evitar; aqui o
+ * índice `fiscal_rule_lookup_idx` reduz o conjunto a um punhado antes de o
+ * motor tocar nele.
+ *
+ * A regra do ESCRITÓRIO tem precedência sobre a global na mesma jurisdição —
+ * `DISTINCT ON` com `tenant_id NULLS LAST`, o mesmo padrão de
+ * `recurring_item_type`.
+ */
+export async function candidateRules(tx, input) {
+    const rows = await tx `
+    SELECT DISTINCT ON (jurisdiction_scope, coalesce(jurisdiction_uf,'-'), coalesce(jurisdiction_city_ibge,'-'))
+           ${tx.unsafe(RULE_COLS)}
+      FROM fiscal_rule
+     WHERE deleted_at IS NULL
+       AND item_type_id = ${input.itemTypeId}
+       AND valid_from <= ${input.referenceDate}::date
+       AND (valid_until IS NULL OR valid_until >= ${input.referenceDate}::date)
+       AND (
+         jurisdiction_scope = 'federal'
+         OR (jurisdiction_scope = 'state'
+             AND jurisdiction_uf = ${input.jurisdiction.uf})
+         OR (jurisdiction_scope = 'municipal'
+             AND jurisdiction_uf = ${input.jurisdiction.uf}
+             AND jurisdiction_city_ibge = ${input.jurisdiction.cityIbge})
+       )
+     ORDER BY jurisdiction_scope, coalesce(jurisdiction_uf,'-'), coalesce(jurisdiction_city_ibge,'-'),
+              tenant_id NULLS LAST, version DESC
+  `;
+    return rows.map(mapRule);
+}
+/**
+ * A regra mais específica que alcança o cliente.
+ *
+ * Municipal vence estadual, que vence federal. Um município que legisla sobre
+ * a obrigação está mais perto do fato que a União.
+ */
+export async function resolveRule(tx, input) {
+    const candidatas = await candidateRules(tx, input);
+    const ordem = { municipal: 0, state: 1, federal: 2 };
+    return ([...candidatas].sort((a, b) => ordem[a.jurisdiction.scope] - ordem[b.jurisdiction.scope])[0] ??
+        null);
+}
+/**
+ * Cria uma regra.
+ *
+ * A condição é validada AQUI, na escrita. Gravar uma AST malformada seria
+ * empurrar o erro para a madrugada da geração, onde a única saída seria não
+ * gerar sem explicar.
+ */
+export async function createFiscalRule(tx, input) {
+    parseCondition(input.conditions ?? { op: 'always' });
+    const status = input.status ?? 'pending_validation';
+    if (status === 'validated' && !input.validatedBy) {
+        throw new Error('Uma regra validada precisa de quem a validou.');
+    }
+    const validadaEm = status === 'validated' ? new Date() : null;
+    const validadaPor = status === 'validated' ? input.validatedBy : null;
+    // Três destinos possíveis, e cada um precisa de SQL diferente:
+    //
+    //   `tenantId: null`      → regra GLOBAL. Só o provisionamento consegue: a
+    //                           policy recusa `tenant_id NULL` vindo de sessão
+    //                           com tenant, e é essa recusa que impede um
+    //                           escritório de forjar regra nacional.
+    //   `tenantId: '<uuid>'`  → tenant explícito (provisionamento).
+    //   ausente               → o tenant da sessão, lido da GUC.
+    //
+    // Resolver isso com um único parâmetro misturaria valor e fragmento SQL —
+    // que compila e não faz o que parece.
+    const global = input.tenantId === null;
+    const explicito = typeof input.tenantId === 'string' ? input.tenantId : null;
+    const cond = tx.json((input.conditions ?? { op: 'always' }));
+    const due = input.dueRule ? tx.json(input.dueRule) : null;
+    const rows = global
+        ? await tx `
+        INSERT INTO fiscal_rule (
+          id, tenant_id, item_type_id, jurisdiction_scope, jurisdiction_uf, jurisdiction_city_ibge,
+          version, valid_from, valid_until, status, conditions, due_rule, source_reference, note,
+          validated_by, validated_at
+        ) VALUES (
+          ${uuidv7()}, NULL, ${input.itemTypeId}, ${input.jurisdictionScope},
+          ${input.jurisdictionUf ?? null}, ${input.jurisdictionCityIbge ?? null},
+          ${input.version ?? 1}, ${input.validFrom}, ${input.validUntil ?? null},
+          ${status}, ${cond}, ${due},
+          ${input.sourceReference ?? null}, ${input.note ?? null}, ${validadaPor}, ${validadaEm}
+        )
+        RETURNING ${tx.unsafe(RULE_COLS)}
+      `
+        : await tx `
+        INSERT INTO fiscal_rule (
+          id, tenant_id, item_type_id, jurisdiction_scope, jurisdiction_uf, jurisdiction_city_ibge,
+          version, valid_from, valid_until, status, conditions, due_rule, source_reference, note,
+          validated_by, validated_at
+        ) VALUES (
+          ${uuidv7()},
+          ${explicito ?? tx.unsafe("current_setting('app.current_tenant')::uuid")},
+          ${input.itemTypeId}, ${input.jurisdictionScope},
+          ${input.jurisdictionUf ?? null}, ${input.jurisdictionCityIbge ?? null},
+          ${input.version ?? 1}, ${input.validFrom}, ${input.validUntil ?? null},
+          ${status}, ${cond}, ${due},
+          ${input.sourceReference ?? null}, ${input.note ?? null}, ${validadaPor}, ${validadaEm}
+        )
+        RETURNING ${tx.unsafe(RULE_COLS)}
+      `;
+    return mapRule(rows[0]);
+}
+/**
+ * Publica uma nova versão, encerrando a anterior.
+ *
+ * **Não altera a versão antiga.** Ela recebe `valid_until` e continua lá,
+ * inteira: é ela que explica as obrigações já geradas. Editar a regra vigente
+ * em vez de versioná-la é como a mudança de amanhã reescreve o vencimento de
+ * ontem — e ninguém consegue mais dizer por que aquela data foi aquela.
+ */
+export async function supersedeFiscalRule(tx, input) {
+    const [atual] = await tx `
+    SELECT ${tx.unsafe(RULE_COLS)} FROM fiscal_rule
+     WHERE id = ${input.currentRuleId} AND deleted_at IS NULL
+  `;
+    if (!atual)
+        throw new Error('Regra não encontrada.');
+    if (input.validFrom <= iso(atual.valid_from)) {
+        throw new Error('A nova versão precisa começar depois do início da anterior.');
+    }
+    // O dia anterior ao início da nova: sem vão e sem sobreposição.
+    const fim = new Date(`${input.validFrom}T00:00:00Z`);
+    fim.setUTCDate(fim.getUTCDate() - 1);
+    await tx `
+    UPDATE fiscal_rule SET valid_until = ${iso(fim)}, updated_at = now()
+     WHERE id = ${input.currentRuleId}
+  `;
+    const proxima = await createFiscalRule(tx, {
+        itemTypeId: atual.item_type_id,
+        jurisdictionScope: atual.jurisdiction_scope,
+        jurisdictionUf: atual.jurisdiction_uf,
+        jurisdictionCityIbge: atual.jurisdiction_city_ibge,
+        validFrom: input.validFrom,
+        version: atual.version + 1,
+        tenantId: atual.tenant_id,
+        conditions: input.changes.conditions ?? atual.conditions,
+        dueRule: input.changes.dueRule ?? atual.due_rule,
+        status: input.changes.status ?? 'pending_validation',
+        sourceReference: input.changes.sourceReference ?? atual.source_reference,
+        ...(input.changes.note !== undefined ? { note: input.changes.note } : {}),
+    });
+    return { previous: mapRule({ ...atual, valid_until: fim }), next: proxima };
+}
+export async function getFiscalRule(tx, id) {
+    const [r] = await tx `
+    SELECT ${tx.unsafe(RULE_COLS)} FROM fiscal_rule WHERE id = ${id} AND deleted_at IS NULL
+  `;
+    return r ? mapRule(r) : null;
+}
+export async function setTenantRulePolicy(tx, input) {
+    await tx `
+    INSERT INTO tenant_rule_policy
+      (id, tenant_id, item_type_id, internal_lead_days, enabled, note, updated_by)
+    VALUES (
+      ${uuidv7()}, current_setting('app.current_tenant')::uuid, ${input.itemTypeId},
+      ${input.internalLeadDays ?? null}, ${input.enabled ?? true}, ${input.note ?? null},
+      ${input.actorId ?? null}
+    )
+    ON CONFLICT (tenant_id, item_type_id) DO UPDATE SET
+      internal_lead_days = EXCLUDED.internal_lead_days,
+      enabled = EXCLUDED.enabled,
+      note = EXCLUDED.note,
+      updated_by = EXCLUDED.updated_by,
+      updated_at = now()
+  `;
+}
+export async function listTenantRulePolicies(tx) {
+    const rows = await tx `
+    SELECT item_type_id, internal_lead_days, enabled, note FROM tenant_rule_policy
+  `;
+    return rows.map((r) => ({
+        itemTypeId: r.item_type_id,
+        internalLeadDays: r.internal_lead_days,
+        enabled: r.enabled,
+        note: r.note,
+    }));
+}
+/**
+ * A fila inteira: global e do escritório, com a procedência de cada linha.
+ *
+ * Sem filtro de vigência nem de jurisdição, ao contrário de `candidateRules` —
+ * são perguntas diferentes. Aquela responde "qual regra vale para este cliente
+ * hoje"; esta responde "o que existe e o que ainda não foi conferido", e uma
+ * regra vencida ou de outra UF continua sendo trabalho de governança.
+ */
+export async function listGovernanceRules(tx) {
+    const rows = await tx `
+    SELECT r.id, r.tenant_id, r.item_type_id,
+           t.key AS item_key, t.label AS item_label, t.sphere,
+           r.jurisdiction_scope, r.jurisdiction_uf, r.jurisdiction_city_ibge,
+           r.version, r.valid_from, r.valid_until, r.status,
+           r.source_reference, r.source_url, r.validated_at,
+           u.full_name AS validated_by_name, r.note
+      FROM fiscal_rule r
+      JOIN recurring_item_type t ON t.id = r.item_type_id
+      LEFT JOIN "user" u ON u.id = r.validated_by
+     WHERE r.deleted_at IS NULL AND t.deleted_at IS NULL
+     ORDER BY (r.status <> 'validated') DESC, t.sphere, t.label, r.version DESC
+  `;
+    return rows.map((r) => ({
+        id: r.id,
+        itemTypeId: r.item_type_id,
+        itemTypeKey: r.item_key,
+        itemTypeLabel: r.item_label,
+        sphere: r.sphere,
+        origin: r.tenant_id === null ? 'global' : 'tenant',
+        jurisdiction: {
+            scope: r.jurisdiction_scope,
+            uf: r.jurisdiction_uf,
+            cityIbge: r.jurisdiction_city_ibge,
+        },
+        version: r.version,
+        validFrom: iso(r.valid_from),
+        validUntil: r.valid_until ? iso(r.valid_until) : null,
+        status: r.status,
+        sourceReference: r.source_reference,
+        sourceUrl: r.source_url,
+        validatedAt: r.validated_at ? r.validated_at.toISOString() : null,
+        validatedByName: r.validated_by_name,
+        note: r.note,
+        // Regra global é do PRODUTO. O escritório lê, cria a própria em cima, e não
+        // reescreve a de todo mundo — a RLS já recusaria, e oferecer o botão seria
+        // prometer uma ação que o banco nega.
+        editable: r.tenant_id !== null,
+    }));
+}
+export function summarizeGovernance(rules) {
+    const byStatus = {};
+    for (const r of rules)
+        byStatus[r.status] = (byStatus[r.status] ?? 0) + 1;
+    const withSource = rules.filter((r) => r.sourceUrl || r.sourceReference).length;
+    return {
+        total: rules.length,
+        byStatus,
+        withSource,
+        withoutSource: rules.length - withSource,
+        /*
+         * "Pronta para revisão" NÃO é "validada".
+         *
+         * Uma regra entra nesta contagem quando está pendente E tem uma fonte
+         * oficial anexada — ou seja, quando existe algo concreto para a pessoa
+         * conferir. Sem a fonte, pedir conferência é pedir que alguém procure a
+         * norma sozinho, e é assim que uma fila de governança vira uma fila parada.
+         */
+        readyForHumanReview: rules.filter((r) => r.status === 'pending_validation' && Boolean(r.sourceUrl || r.sourceReference)).length,
+    };
+}
+/**
+ * Registra a fonte e a observação de uma regra DO ESCRITÓRIO.
+ *
+ * Separado de validar de propósito: anexar evidência é preparação, e quem
+ * prepara não carimba. Não toca em `status`.
+ */
+export async function annotateFiscalRule(tx, input) {
+    if (input.sourceUrl && !/^https:\/\/[^\s"'<>]+$/i.test(input.sourceUrl)) {
+        throw new ValidationError('A fonte precisa ser uma URL https.');
+    }
+    const rows = await tx `
+    UPDATE fiscal_rule
+       SET source_url       = COALESCE(${input.sourceUrl ?? null}, source_url),
+           source_reference = COALESCE(${input.sourceReference ?? null}, source_reference),
+           note             = COALESCE(${input.note ?? null}, note),
+           updated_at       = now()
+     WHERE id = ${input.id} AND tenant_id IS NOT NULL AND deleted_at IS NULL
+    RETURNING id
+  `;
+    if (!rows[0]) {
+        throw new ValidationError('Regra não encontrada neste escritório. Regras globais do produto não são editáveis aqui — crie uma regra do escritório para sobrepor.');
+    }
+}
+/**
+ * O carimbo humano de conferência.
+ *
+ * Três guardas, e nenhum é redundante:
+ *
+ * 1. **Só regra do escritório.** A global é do produto; conferi-la para todo o
+ *    Brasil não é decisão de um tenant.
+ * 2. **`validatedBy` obrigatório e vindo da SESSÃO**, nunca do corpo. Uma regra
+ *    validada precisa responder "quem conferiu" com um nome que a pessoa não
+ *    escolheu para si.
+ * 3. **Fonte obrigatória.** Validar sem apontar a norma é registrar uma opinião
+ *    com aparência de conferência — e é exatamente o que a trilha não deve
+ *    permitir que se pareça com evidência depois.
+ */
+export async function validateFiscalRule(tx, input) {
+    const atual = await tx `
+    SELECT id, source_url, source_reference FROM fiscal_rule
+     WHERE id = ${input.id} AND tenant_id IS NOT NULL AND deleted_at IS NULL
+  `;
+    const regra = atual[0];
+    if (!regra) {
+        throw new ValidationError('Regra não encontrada neste escritório. Regras globais do produto não são conferidas aqui.');
+    }
+    if (!regra.source_url && !regra.source_reference) {
+        throw new ValidationError('Antes de conferir, registre a fonte oficial da regra. Conferência sem fonte não é evidência.');
+    }
+    await tx `
+    UPDATE fiscal_rule
+       SET status = 'validated',
+           validated_by = ${input.validatedBy},
+           validated_at = now(),
+           note = COALESCE(${input.note ?? null}, note),
+           updated_at = now()
+     WHERE id = ${input.id} AND tenant_id IS NOT NULL AND deleted_at IS NULL
+  `;
+}
+//# sourceMappingURL=repository.js.map