@tiangong-lca/cli 0.1.0 → 0.1.2

package/dist/src/lib/process-list.d.ts

@@ -0,0 +1,87 @@
+import type { FetchLike } from './http.js';
+type JsonObject = Record<string, unknown>;
+type ProcessListQueryFilters = {
+    ids?: string[];
+    version?: string | null;
+    userId?: string | null;
+    stateCodes?: number[];
+    order?: string | null;
+    limit?: number | null;
+    offset?: number | null;
+};
+type SupabaseProcessListRow = {
+    id: string;
+    version: string;
+    user_id: string | null;
+    state_code: number | null;
+    modified_at: string | null;
+    json: unknown;
+};
+export type RunProcessListOptions = {
+    ids?: string[];
+    version?: string | null;
+    userId?: string | null;
+    stateCodes?: number[];
+    limit?: number | null;
+    offset?: number | null;
+    all?: boolean;
+    pageSize?: number | null;
+    order?: string | null;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+    now?: Date;
+    maxAttempts?: number | null;
+};
+export type ProcessListReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'listed_remote_processes';
+    filters: {
+        ids: string[];
+        requested_version: string | null;
+        requested_user_id: string | null;
+        requested_state_codes: number[];
+        order: string;
+        all: boolean;
+        limit: number | null;
+        offset: number;
+        page_size: number | null;
+    };
+    count: number;
+    source_urls: string[];
+    rows: Array<{
+        id: string;
+        version: string;
+        user_id: string | null;
+        state_code: number | null;
+        modified_at: string | null;
+        process: JsonObject;
+    }>;
+};
+declare function normalizeToken(value: string | null | undefined): string | null;
+declare function nowIso(now?: Date): string;
+declare function toPositiveInteger(value: number | null | undefined, label: string, code: string): number;
+declare function toNonNegativeInteger(value: number | null | undefined, label: string, code: string): number;
+declare function optionalPositiveInteger(value: number | null | undefined): number | null;
+declare function optionalNonNegativeInteger(value: number | null | undefined): number | null;
+declare function buildProcessListUrl(restBaseUrl: string, filters: ProcessListQueryFilters): string;
+declare function parseProcessRows(payload: unknown, url: string): SupabaseProcessListRow[];
+declare function applyOrder<Query extends {
+    order: (column: string, options?: object) => Query;
+}>(query: Query, orderValue: string | null | undefined): Query;
+declare function isRetryableError(error: unknown): boolean;
+export declare function runProcessList(options: RunProcessListOptions): Promise<ProcessListReport>;
+export declare const __testInternals: {
+    applyOrder: typeof applyOrder;
+    buildProcessListUrl: typeof buildProcessListUrl;
+    isRetryableError: typeof isRetryableError;
+    normalizeToken: typeof normalizeToken;
+    nowIso: typeof nowIso;
+    optionalNonNegativeInteger: typeof optionalNonNegativeInteger;
+    optionalPositiveInteger: typeof optionalPositiveInteger;
+    parseProcessRows: typeof parseProcessRows;
+    toNonNegativeInteger: typeof toNonNegativeInteger;
+    toPositiveInteger: typeof toPositiveInteger;
+};
+export {};

package/dist/src/lib/process-payload-validation.d.ts

@@ -0,0 +1,27 @@
+import { type SafeParseSchema, type SdkValidationFactory } from './tidas-sdk-validation.js';
+type JsonObject = Record<string, unknown>;
+export type ProcessPayloadValidationIssue = {
+    path: string;
+    message: string;
+    code: string;
+};
+export type ProcessPayloadValidationResult = {
+    ok: true;
+    validator: string;
+    issue_count: 0;
+    issues: [];
+} | {
+    ok: false;
+    validator: string;
+    issue_count: number;
+    issues: ProcessPayloadValidationIssue[];
+};
+declare function getProcessFactory(sdk?: {
+    createProcess?: unknown;
+}): SdkValidationFactory | null;
+export declare function summarizeProcessPayloadValidation(result: ProcessPayloadValidationResult): string;
+export declare function validateProcessPayload(payload: JsonObject, schema?: SafeParseSchema, createEntity?: SdkValidationFactory | null): ProcessPayloadValidationResult;
+export declare const __testInternals: {
+    getProcessFactory: typeof getProcessFactory;
+};
+export {};

package/dist/src/lib/process-publish-build.d.ts

@@ -0,0 +1,148 @@
+import { type ProcessPayloadValidationResult } from './process-payload-validation.js';
+type JsonRecord = Record<string, unknown>;
+type DatasetOrigin = 'exports' | 'state';
+type GateSeverity = 'info' | 'warning' | 'blocker';
+type ProcessGateFinding = {
+    code: string;
+    severity: GateSeverity;
+    methodology_rule_id: string | null;
+    message: string;
+    path: string;
+    dataset_index: number;
+    dataset_id: string | null;
+    dataset_version: string | null;
+};
+export type ProcessPublishBuildLayout = {
+    runId: string;
+    runRoot: string;
+    collectionDir: string;
+    cacheDir: string;
+    manifestsDir: string;
+    reportsDir: string;
+    processExportsDir: string;
+    sourceExportsDir: string;
+    publishStageDir: string;
+    statePath: string;
+    handoffSummaryPath: string;
+    runManifestPath: string;
+    invocationIndexPath: string;
+    publishBundlePath: string;
+    publishRequestPath: string;
+    publishIntentPath: string;
+    processSchemaGatePath: string;
+    reportPath: string;
+};
+export type ProcessPublishSchemaGateReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'passed' | 'blocked';
+    ruleset_id: string;
+    ruleset_version: string;
+    ruleset_source_version: string;
+    ruleset_rule_ids: string[];
+    validator: string;
+    counts: {
+        total: number;
+        valid: number;
+        invalid: number;
+    };
+    findings: ProcessGateFinding[];
+    blockers: ProcessGateFinding[];
+    next_action: 'write_publish_bundle' | 'fix_process_payloads';
+    processes: Array<{
+        index: number;
+        id: string | null;
+        version: string | null;
+        ok: boolean;
+        issue_count: number;
+        issues: ProcessPayloadValidationResult['issues'];
+    }>;
+};
+export type ProcessPublishBuildReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'prepared_local_process_publish_bundle';
+    run_id: string;
+    run_root: string;
+    request_id: string | null;
+    state_summary: {
+        build_status: string | null;
+        next_stage: string | null;
+        stop_after: string | null;
+    };
+    dataset_origins: {
+        processes: DatasetOrigin;
+        sources: DatasetOrigin;
+    };
+    counts: {
+        processes: number;
+        sources: number;
+        relations: number;
+    };
+    publish_defaults: {
+        commit: boolean;
+        publish_lifecyclemodels: boolean;
+        publish_processes: boolean;
+        publish_sources: boolean;
+        publish_relations: boolean;
+        publish_process_build_runs: boolean;
+        relation_mode: 'local_manifest_only';
+    };
+    files: {
+        state: string;
+        handoff_summary: string;
+        run_manifest: string;
+        invocation_index: string;
+        publish_bundle: string;
+        publish_request: string;
+        publish_intent: string;
+        process_schema_gate: string;
+        report: string;
+    };
+    next_actions: string[];
+};
+export type RunProcessPublishBuildOptions = {
+    runId?: string;
+    runDir?: string | null;
+    now?: Date;
+    cwd?: string;
+    validateProcessPayloadImpl?: (payload: JsonRecord) => ProcessPayloadValidationResult;
+};
+declare function buildLayout(runRoot: string, runId: string): ProcessPublishBuildLayout;
+declare function resolveLayout(options: RunProcessPublishBuildOptions): ProcessPublishBuildLayout;
+declare function buildStateSummary(state: JsonRecord): ProcessPublishBuildReport['state_summary'];
+declare function readDatasetArrayFromState(state: JsonRecord, key: 'process_datasets' | 'source_datasets'): JsonRecord[];
+declare function collectCanonicalDatasets(layout: ProcessPublishBuildLayout, state: JsonRecord): {
+    processes: JsonRecord[];
+    processOrigin: DatasetOrigin;
+    sources: JsonRecord[];
+    sourceOrigin: DatasetOrigin;
+};
+declare function buildUpdatedState(state: JsonRecord, layout: ProcessPublishBuildLayout, counts: ProcessPublishBuildReport['counts'], datasetOrigins: ProcessPublishBuildReport['dataset_origins'], now: Date): JsonRecord;
+declare function buildInvocationIndex(layout: ProcessPublishBuildLayout, invocationIndex: JsonRecord, options: RunProcessPublishBuildOptions, now: Date): JsonRecord;
+declare function buildPublishRequest(): JsonRecord;
+declare function buildPublishIntent(layout: ProcessPublishBuildLayout, counts: ProcessPublishBuildReport['counts']): JsonRecord;
+declare function buildNextActions(layout: ProcessPublishBuildLayout): string[];
+declare function buildReport(layout: ProcessPublishBuildLayout, state: JsonRecord, counts: ProcessPublishBuildReport['counts'], datasetOrigins: ProcessPublishBuildReport['dataset_origins'], publishDefaults: ProcessPublishBuildReport['publish_defaults'], now: Date): ProcessPublishBuildReport;
+declare function buildProcessSchemaGateReport(processes: JsonRecord[], options: {
+    now: Date;
+    validateProcessPayloadImpl?: (payload: JsonRecord) => ProcessPayloadValidationResult;
+}): ProcessPublishSchemaGateReport;
+declare function assertProcessSchemaGatePassed(gate: ProcessPublishSchemaGateReport, layout: ProcessPublishBuildLayout): void;
+export declare function runProcessPublishBuild(options: RunProcessPublishBuildOptions): Promise<ProcessPublishBuildReport>;
+export declare const __testInternals: {
+    buildLayout: typeof buildLayout;
+    resolveLayout: typeof resolveLayout;
+    buildStateSummary: typeof buildStateSummary;
+    readDatasetArrayFromState: typeof readDatasetArrayFromState;
+    collectCanonicalDatasets: typeof collectCanonicalDatasets;
+    buildPublishRequest: typeof buildPublishRequest;
+    buildPublishIntent: typeof buildPublishIntent;
+    buildProcessSchemaGateReport: typeof buildProcessSchemaGateReport;
+    assertProcessSchemaGatePassed: typeof assertProcessSchemaGatePassed;
+    buildUpdatedState: typeof buildUpdatedState;
+    buildInvocationIndex: typeof buildInvocationIndex;
+    buildNextActions: typeof buildNextActions;
+    buildReport: typeof buildReport;
+};
+export {};

package/dist/src/lib/process-qa.d.ts

@@ -0,0 +1,243 @@
+import type { FetchLike } from './http.js';
+type JsonRecord = Record<string, unknown>;
+type BaseInfoCheck = {
+    source_name_ok: boolean;
+    functional_unit_ok: boolean;
+    system_boundary_ok: boolean;
+    time_ok: boolean;
+    geo_ok: boolean;
+    tech_ok: boolean;
+    admin_ok: boolean;
+    completeness_score: number;
+    base_names: string[];
+};
+type ClassifiedExchange = {
+    classification: 'raw_material_input' | 'energy_input' | 'other_input' | 'product_output' | 'byproduct_output' | 'waste_output' | 'other_output' | 'other';
+    kinds: string[];
+    uoms: string[];
+    blob: string;
+    source_input_group: string | null;
+    source_output_group: string | null;
+    reference_flow: boolean;
+};
+type UnitIssue = {
+    flow_uuid: string;
+    current_unit: string;
+    suggested_unit: string;
+    basis: string;
+    confidence: string;
+};
+type ProcessQaRow = {
+    process_file: string;
+    raw_input: number;
+    product: number;
+    byproduct: number;
+    waste: number;
+    energy_excluded: number;
+    delta: number;
+    relative_deviation: number | null;
+};
+type ProcessQaTotals = {
+    raw_input: number;
+    product_plus_byproduct_plus_waste: number;
+    delta: number;
+    relative_deviation: number | null;
+    energy_excluded: number;
+};
+type ProcessQaFinding = {
+    process_file: string;
+    severity: 'info' | 'warning' | 'blocker';
+    code: string;
+    methodology_rule_id: string | null;
+    message: string;
+    source: 'rule';
+    evidence?: JsonRecord;
+};
+type ProcessRulesetGate = {
+    status: 'passed' | 'needs_review' | 'blocked';
+    ruleset_id: 'process-authoring/strict';
+    ruleset_version: '1';
+    ruleset_source_version: string;
+    ruleset_rule_ids: string[];
+    counts: {
+        findings: number;
+        blockers: number;
+    };
+    blockers: ProcessQaFinding[];
+    next_action: 'continue' | 'review_findings_in_foundry' | 'fix_blockers';
+};
+type ProcessSummaryForLlm = {
+    process_file: string;
+    base_names: string[];
+    base_checks: {
+        source_name_ok: boolean;
+        functional_unit_ok: boolean;
+        system_boundary_ok: boolean;
+        time_ok: boolean;
+        geo_ok: boolean;
+        tech_ok: boolean;
+        admin_ok: boolean;
+    };
+    balance: {
+        raw_in: number;
+        product: number;
+        byproduct: number;
+        waste: number;
+        energy_excluded: number;
+        relative_deviation: number | null;
+    };
+};
+export type ProcessQaLlmResult = {
+    enabled: false;
+    reason: string;
+} | {
+    enabled: true;
+    ok: true;
+    result: JsonRecord;
+} | {
+    enabled: true;
+    ok: false;
+    reason: string;
+    raw?: string;
+};
+export type ProcessQaSummary = {
+    run_id: string;
+    logic_version: string;
+    process_count: number;
+    totals: ProcessQaTotals;
+    ruleset_gate?: ProcessRulesetGate;
+    llm: ProcessQaLlmResult;
+    policy_decision_owner: 'foundry';
+    qa_mode: 'deterministic_qa_report';
+};
+export type ProcessQaReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'completed_local_process_qa';
+    run_id: string;
+    run_root: string;
+    rows_file: string;
+    out_dir: string;
+    input_mode: 'rows_file' | 'run_root';
+    effective_processes_dir: string;
+    logic_version: string;
+    ruleset_id?: 'process-authoring/strict';
+    ruleset_version?: '1';
+    ruleset_source_version?: string;
+    ruleset_rule_ids?: string[];
+    process_count: number;
+    totals: ProcessQaTotals;
+    rule_finding_count?: number;
+    blocker_count?: number;
+    ruleset_gate?: ProcessRulesetGate;
+    policy_decision_owner: 'foundry';
+    qa_mode: 'deterministic_qa_report';
+    files: {
+        qa_input_summary: string;
+        materialization_summary: string | null;
+        rule_findings?: string;
+        ruleset_gate?: string;
+        qa_zh: string;
+        qa_en: string;
+        timing: string;
+        unit_issue_log: string;
+        summary: string;
+        report: string;
+    };
+    llm: ProcessQaLlmResult;
+};
+export type RunProcessQaOptions = {
+    rowsFile?: string;
+    runRoot?: string;
+    runId?: string;
+    outDir: string;
+    startTs?: string;
+    endTs?: string;
+    logicVersion?: string;
+    enableLlm?: boolean;
+    llmModel?: string;
+    llmMaxProcesses?: number;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    now?: () => Date;
+};
+declare function requiredNonEmpty(value: string | undefined, label: string, code: string): string;
+declare function textFromValue(value: unknown): string;
+declare function toNumber(value: unknown): number;
+declare function deepGet(value: unknown, pathParts: string[]): unknown;
+declare function hasNonEmpty(value: unknown): boolean;
+declare function extractBaseNames(processPayload: JsonRecord): [boolean, string[]];
+declare function classifyExchange(exchange: JsonRecord, referenceFlowId?: string | null): ClassifiedExchange;
+declare function unitIssueCheck(exchange: JsonRecord, uoms: string[], blob: string): UnitIssue[];
+declare function hasNumericAmount(exchange: JsonRecord): boolean;
+declare function createProcessQaFinding(options: {
+    processFile: string;
+    severity: ProcessQaFinding['severity'];
+    code: string;
+    message: string;
+    evidence?: JsonRecord;
+}): ProcessQaFinding;
+declare function reviewFindingsForBase(processFile: string, base: BaseInfoCheck): ProcessQaFinding[];
+declare function processRulesetGate(findings: ProcessQaFinding[]): ProcessRulesetGate;
+declare function baseInfoCheck(processPayload: JsonRecord): BaseInfoCheck;
+declare function unwrapProcessPayload(value: unknown, filePath: string): JsonRecord;
+declare function buildPrompt(processSummaries: ProcessSummaryForLlm[]): string;
+declare function parseLlmJsonOutput(output: string): JsonRecord | null;
+declare function runOptionalLlmReview(processSummaries: ProcessSummaryForLlm[], options: {
+    enableLlm: boolean;
+    llmModel: string | undefined;
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+    outDir: string;
+}): Promise<ProcessQaLlmResult>;
+declare function renderZhReview(options: {
+    runId: string;
+    logicVersion: string;
+    baseRows: Array<[string, BaseInfoCheck]>;
+    rows: ProcessQaRow[];
+    totals: ProcessQaTotals;
+    llmResult: ProcessQaLlmResult;
+    evidenceStrong: string[];
+    evidenceWeak: string[];
+}): string;
+declare function renderEnReview(options: {
+    runId: string;
+    logicVersion: string;
+    baseRows: Array<[string, BaseInfoCheck]>;
+    rows: ProcessQaRow[];
+    totals: ProcessQaTotals;
+    evidenceStrong: string[];
+    evidenceWeak: string[];
+}): string;
+declare function renderTiming(options: {
+    runId: string;
+    startTs: string | undefined;
+    endTs: string | undefined;
+    processCount: number;
+}): string;
+declare function renderUnitIssues(runId: string, unitIssues: UnitIssue[]): string;
+export declare function runProcessQa(options: RunProcessQaOptions): Promise<ProcessQaReport>;
+export declare const __testInternals: {
+    requiredNonEmpty: typeof requiredNonEmpty;
+    textFromValue: typeof textFromValue;
+    toNumber: typeof toNumber;
+    deepGet: typeof deepGet;
+    hasNonEmpty: typeof hasNonEmpty;
+    extractBaseNames: typeof extractBaseNames;
+    classifyExchange: typeof classifyExchange;
+    unitIssueCheck: typeof unitIssueCheck;
+    hasNumericAmount: typeof hasNumericAmount;
+    createProcessQaFinding: typeof createProcessQaFinding;
+    reviewFindingsForBase: typeof reviewFindingsForBase;
+    processRulesetGate: typeof processRulesetGate;
+    baseInfoCheck: typeof baseInfoCheck;
+    unwrapProcessPayload: typeof unwrapProcessPayload;
+    buildPrompt: typeof buildPrompt;
+    parseLlmJsonOutput: typeof parseLlmJsonOutput;
+    runOptionalLlmReview: typeof runOptionalLlmReview;
+    renderZhReview: typeof renderZhReview;
+    renderEnReview: typeof renderEnReview;
+    renderTiming: typeof renderTiming;
+    renderUnitIssues: typeof renderUnitIssues;
+};
+export {};

package/dist/src/lib/process-refresh-references.d.ts

@@ -0,0 +1,179 @@
+import type { FetchLike, ResponseLike } from './http.js';
+import { type ProcessStateAwareWriteResult, type SyncStateAwareProcessRecordOptions } from './process-save-draft.js';
+import { type ProcessPayloadValidationResult } from './process-payload-validation.js';
+type JsonObject = Record<string, unknown>;
+type ProcessManifestRow = {
+    id: string;
+    version: string;
+    modified_at: string | null;
+    state_code: number | null;
+    model_id: string | null;
+};
+type LatestReferenceRow = {
+    id: string;
+    version: string;
+    json: JsonObject;
+    modified_at: string | null;
+    state_code: number | null;
+    user_id: string | null;
+    team_id: string | null;
+};
+type LatestReferenceCacheEntry = {
+    row: LatestReferenceRow | null;
+    count: number;
+    error?: string;
+};
+type ReferenceNode = JsonObject & {
+    '@refObjectId': string;
+    '@version': string;
+    '@type': string;
+};
+type CollectedReference = {
+    node: ReferenceNode;
+    path: string;
+};
+type TouchedReference = {
+    id: string;
+    type: string;
+    from_version: string;
+    to_version: string;
+    path: string;
+};
+type UnresolvedReference = {
+    id: string;
+    type: string;
+    version: string;
+    reason: string;
+};
+type UpdateSummary = {
+    version_updates: number;
+    description_updates: number;
+    touched_refs: TouchedReference[];
+    unresolved_refs: UnresolvedReference[];
+};
+type RefreshManifest = {
+    schema_version: 1;
+    generated_at_utc: string;
+    user_id: string;
+    masked_user_email: string;
+    source: 'current_user_processes';
+    order: 'modified_at.desc,id.asc';
+    page_size: number;
+    count: number;
+    rows: ProcessManifestRow[];
+};
+export type ProcessRefreshReferencesReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'completed_process_reference_refresh' | 'completed_process_reference_refresh_with_errors';
+    out_dir: string;
+    mode: 'dry_run' | 'apply';
+    user_id: string;
+    masked_user_email: string;
+    counts: {
+        manifest: number;
+        selected: number;
+        already_completed: number;
+        pending: number;
+        saved: number;
+        dry_run: number;
+        skipped: number;
+        validation_blocked: number;
+        errors: number;
+    };
+    files: {
+        manifest: string;
+        progress_jsonl: string;
+        errors_jsonl: string;
+        validation_blockers_jsonl: string;
+        summary_json: string;
+        report_md: string;
+    };
+};
+export type RunProcessRefreshReferencesOptions = {
+    outDir: string;
+    apply?: boolean | null;
+    reuseManifest?: boolean | null;
+    limit?: number | null;
+    pageSize?: number | null;
+    concurrency?: number | null;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+    maxRetries?: number;
+    now?: Date;
+    validateProcessPayloadImpl?: (payload: JsonObject) => ProcessPayloadValidationResult;
+    syncStateAwareProcessRecordImpl?: (options: SyncStateAwareProcessRecordOptions) => Promise<ProcessStateAwareWriteResult>;
+};
+declare function normalizeReferenceType(type: string): string;
+declare function tableForReferenceType(type: string): string | null;
+declare function recordKey(row: Pick<ProcessManifestRow, 'id' | 'version'>): string;
+declare function parseContentRangeTotal(value: string | null): number | null;
+declare function compareVersions(left: string, right: string): number;
+declare function getLangList(value: unknown): JsonObject[];
+declare function getLangText(value: unknown, lang: string | null): string;
+declare function genFlowName(name: JsonObject | null, lang: string): string;
+declare function genFlowNameJson(name: JsonObject | null): JsonObject[];
+declare function genProcessName(name: JsonObject | null, lang: string): string;
+declare function genProcessNameJson(name: JsonObject | null): JsonObject[];
+declare function normalizeDatasetPayload(payload: unknown, label: string): JsonObject;
+declare function getShortDescription(payload: JsonObject, type: string): JsonObject[];
+declare function parseJsonResponse(response: ResponseLike, label: string): Promise<unknown>;
+declare function fetchJsonWithRetry(options: {
+    url: string;
+    init: RequestInit;
+    label: string;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    maxRetries: number;
+}): Promise<{
+    status: number;
+    headers: Headers;
+    body: unknown;
+}>;
+declare function normalizeManifestRow(value: unknown): ProcessManifestRow | null;
+declare function readManifest(filePath: string): RefreshManifest | null;
+declare function readCompleted(progressFile: string, applyMode: boolean): Set<string>;
+declare function collectRefs(root: JsonObject): CollectedReference[];
+declare function fetchLatestRefs(options: {
+    projectBaseUrl: string;
+    publishableKey: string;
+    accessToken: string;
+    refs: CollectedReference[];
+    cache: Map<string, LatestReferenceCacheEntry>;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    maxRetries: number;
+}): Promise<void>;
+declare function updateProcessJson(payload: JsonObject, refs: CollectedReference[], cache: Map<string, LatestReferenceCacheEntry>): UpdateSummary;
+declare function appendReportHeader(reportFile: string, context: {
+    mode: 'dry_run' | 'apply';
+    generatedAtUtc: string;
+    manifestCount: number;
+}): void;
+export declare function runProcessRefreshReferences(options: RunProcessRefreshReferencesOptions): Promise<ProcessRefreshReferencesReport>;
+export declare const __testInternals: {
+    appendReportHeader: typeof appendReportHeader;
+    collectRefs: typeof collectRefs;
+    compareVersions: typeof compareVersions;
+    fetchLatestRefs: typeof fetchLatestRefs;
+    fetchJsonWithRetry: typeof fetchJsonWithRetry;
+    genFlowName: typeof genFlowName;
+    genFlowNameJson: typeof genFlowNameJson;
+    genProcessName: typeof genProcessName;
+    genProcessNameJson: typeof genProcessNameJson;
+    getLangList: typeof getLangList;
+    getLangText: typeof getLangText;
+    getShortDescription: typeof getShortDescription;
+    normalizeReferenceType: typeof normalizeReferenceType;
+    normalizeDatasetPayload: typeof normalizeDatasetPayload;
+    normalizeManifestRow: typeof normalizeManifestRow;
+    parseJsonResponse: typeof parseJsonResponse;
+    parseContentRangeTotal: typeof parseContentRangeTotal;
+    readCompleted: typeof readCompleted;
+    readManifest: typeof readManifest;
+    recordKey: typeof recordKey;
+    tableForReferenceType: typeof tableForReferenceType;
+    updateProcessJson: typeof updateProcessJson;
+};
+export {};