@tiangong-lca/cli 0.1.0 → 0.1.2

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

@@ -0,0 +1,168 @@
+import { type RunLayout } from './run.js';
+type JsonRecord = Record<string, unknown>;
+export type ProcessAutoBuildOperation = 'produce' | 'treat';
+export type ProcessAutoBuildSourceInputType = 'local_file' | 'local_text';
+export type ProcessAutoBuildSourcePolicy = {
+    step1_route: {
+        preferred: string[];
+        fallback: string;
+    };
+    step2_process_split: {
+        preferred: string[];
+        fallback: string;
+    };
+    step3b_exchange_values: {
+        preferred: string[];
+        require_numeric_evidence: boolean;
+        allow_estimation: boolean;
+    };
+};
+export type ProcessAutoBuildFlowSummary = {
+    wrapper: 'flowDataSet' | 'direct';
+    uuid: string | null;
+    version: string | null;
+    base_name: string | null;
+    permanent_uri: string | null;
+};
+export type NormalizedProcessAutoBuildSourceInput = {
+    source_id: string;
+    type: ProcessAutoBuildSourceInputType;
+    source_path: string;
+    artifact_path: string;
+    artifact_file_name: string;
+    intended_roles: string[];
+};
+export type NormalizedProcessAutoBuildRequest = {
+    schema_version: 1;
+    request_path: string;
+    request_id: string;
+    flow_file: string;
+    flow_summary: ProcessAutoBuildFlowSummary;
+    flow_dataset: JsonRecord;
+    operation: ProcessAutoBuildOperation;
+    run_id: string;
+    run_root: string;
+    source_inputs: NormalizedProcessAutoBuildSourceInput[];
+    source_policy: ProcessAutoBuildSourcePolicy;
+};
+export type ProcessAutoBuildLayout = RunLayout & {
+    requestDir: string;
+    evidenceDir: string;
+    evidenceIncomingDir: string;
+    evidenceNormalizedDir: string;
+    evidenceTextDir: string;
+    evidenceStructuredDir: string;
+    stageOutputsDir: string;
+    reviewsDir: string;
+    requestSnapshotPath: string;
+    normalizedRequestPath: string;
+    sourcePolicyPath: string;
+    flowSummaryPath: string;
+    inputManifestPath: string;
+    buildPlanPath: string;
+    assemblyPlanPath: string;
+    lineageManifestPath: string;
+    invocationIndexPath: string;
+    runManifestPath: string;
+    reportPath: string;
+    statePath: string;
+    handoffSummaryPath: string;
+    processExportsDir: string;
+    sourceExportsDir: string;
+};
+export type ProcessAutoBuildReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'prepared_local_process_auto_build_run';
+    request_path: string;
+    request_id: string;
+    run_id: string;
+    run_root: string;
+    operation: ProcessAutoBuildOperation;
+    flow: {
+        source_path: string;
+        artifact_path: string;
+        wrapper: 'flowDataSet' | 'direct';
+        uuid: string | null;
+        version: string | null;
+        base_name: string | null;
+    };
+    source_input_count: number;
+    stage_count: number;
+    files: {
+        request_snapshot: string;
+        normalized_request: string;
+        source_policy: string;
+        flow_summary: string;
+        input_manifest: string;
+        build_plan: string;
+        assembly_plan: string;
+        lineage_manifest: string;
+        invocation_index: string;
+        run_manifest: string;
+        state: string;
+        handoff_summary: string;
+        report: string;
+    };
+    next_actions: string[];
+};
+export type RunProcessAutoBuildOptions = {
+    inputPath: string;
+    outDir?: string | null;
+    now?: Date;
+    cwd?: string;
+    inputValue?: unknown;
+    requestIdOverride?: string;
+    runIdOverride?: string;
+};
+type ProcessAutoBuildStage = {
+    id: string;
+    title: string;
+    output: string;
+    createsCandidatesDir: boolean;
+    modules: string[];
+};
+declare function extractText(value: unknown): string | null;
+declare function normalizeOperation(value: unknown): ProcessAutoBuildOperation;
+declare function normalizeSourcePolicy(value: unknown): ProcessAutoBuildSourcePolicy;
+declare function extractFlowDatasetRoot(payload: unknown): {
+    flowPayload: JsonRecord;
+    flowDataset: JsonRecord;
+    wrapper: 'flowDataSet' | 'direct';
+};
+declare function extractFlowSummary(flowDataset: JsonRecord, wrapper: 'flowDataSet' | 'direct'): ProcessAutoBuildFlowSummary;
+declare function buildProcessAutoBuildRunId(flowFilePath: string, operation: ProcessAutoBuildOperation, summary: ProcessAutoBuildFlowSummary, now?: Date): string;
+declare function buildLayout(runRoot: string, runId: string): ProcessAutoBuildLayout;
+declare function buildAssemblyPlan(runRoot: string): JsonRecord;
+declare function buildInitialProcessBuildPlan(normalized: NormalizedProcessAutoBuildRequest, flowArtifactPath: string): JsonRecord;
+declare function buildLineageManifest(normalized: NormalizedProcessAutoBuildRequest): JsonRecord;
+declare function buildInvocationIndex(normalized: NormalizedProcessAutoBuildRequest, options: RunProcessAutoBuildOptions, reportPath: string, now: Date): JsonRecord;
+declare function buildInitialState(normalized: NormalizedProcessAutoBuildRequest, flowArtifactPath: string, now: Date): JsonRecord;
+declare function buildAgentHandoffSummary(normalized: NormalizedProcessAutoBuildRequest, layout: ProcessAutoBuildLayout, flowArtifactPath: string, now: Date): JsonRecord;
+declare function buildReport(normalized: NormalizedProcessAutoBuildRequest, layout: ProcessAutoBuildLayout, flowArtifactPath: string, now: Date): ProcessAutoBuildReport;
+export declare function normalizeProcessAutoBuildRequest(input: unknown, options: {
+    inputPath: string;
+    outDir?: string | null;
+    now?: Date;
+    requestIdOverride?: string;
+    runIdOverride?: string;
+}): NormalizedProcessAutoBuildRequest;
+export declare function runProcessAutoBuild(options: RunProcessAutoBuildOptions): Promise<ProcessAutoBuildReport>;
+export declare const __testInternals: {
+    PROCESS_AUTO_BUILD_STAGES: ProcessAutoBuildStage[];
+    extractText: typeof extractText;
+    normalizeOperation: typeof normalizeOperation;
+    normalizeSourcePolicy: typeof normalizeSourcePolicy;
+    extractFlowDatasetRoot: typeof extractFlowDatasetRoot;
+    extractFlowSummary: typeof extractFlowSummary;
+    buildProcessAutoBuildRunId: typeof buildProcessAutoBuildRunId;
+    buildLayout: typeof buildLayout;
+    buildAssemblyPlan: typeof buildAssemblyPlan;
+    buildInitialProcessBuildPlan: typeof buildInitialProcessBuildPlan;
+    buildLineageManifest: typeof buildLineageManifest;
+    buildInvocationIndex: typeof buildInvocationIndex;
+    buildInitialState: typeof buildInitialState;
+    buildAgentHandoffSummary: typeof buildAgentHandoffSummary;
+    buildReport: typeof buildReport;
+};
+export {};

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

@@ -0,0 +1,97 @@
+import { type ErrorPayload } from './errors.js';
+import { type RunLayout } from './run.js';
+type JsonRecord = Record<string, unknown>;
+type ProcessBatchBuildStatus = 'completed' | 'completed_with_failures';
+type ProcessBatchBuildItemStatus = 'prepared' | 'failed' | 'skipped';
+type ProcessBatchBuildManifestItem = {
+    item_id: string;
+    input_path: string;
+    out_dir: string;
+};
+export type ProcessBatchBuildLayout = RunLayout & {
+    requestDir: string;
+    runsDir: string;
+    requestSnapshotPath: string;
+    normalizedRequestPath: string;
+    invocationIndexPath: string;
+    runManifestPath: string;
+    reportPath: string;
+};
+export type NormalizedProcessBatchBuildRequest = {
+    schema_version: 1;
+    manifest_path: string;
+    batch_id: string;
+    batch_root: string;
+    continue_on_error: boolean;
+    items: ProcessBatchBuildManifestItem[];
+};
+export type ProcessBatchBuildItemReport = {
+    item_id: string;
+    index: number;
+    input_path: string;
+    out_dir: string;
+    status: ProcessBatchBuildItemStatus;
+    run_id: string | null;
+    run_root: string | null;
+    request_id: string | null;
+    files: {
+        request_snapshot: string | null;
+        report: string | null;
+        state: string | null;
+        handoff_summary: string | null;
+        run_manifest: string | null;
+    };
+    error: ErrorPayload['error'] | null;
+};
+export type ProcessBatchBuildReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: ProcessBatchBuildStatus;
+    manifest_path: string;
+    batch_id: string;
+    batch_root: string;
+    continue_on_error: boolean;
+    counts: {
+        total: number;
+        prepared: number;
+        failed: number;
+        skipped: number;
+    };
+    files: {
+        request_snapshot: string;
+        normalized_request: string;
+        invocation_index: string;
+        run_manifest: string;
+        report: string;
+    };
+    items: ProcessBatchBuildItemReport[];
+    next_actions: string[];
+};
+export type RunProcessBatchBuildOptions = {
+    inputPath: string;
+    outDir?: string | null;
+    now?: Date;
+    cwd?: string;
+};
+declare function resolveBatchRoot(manifestDir: string, outDirOverride: string | null | undefined, requestOutDir: unknown): string;
+declare function buildLayout(batchRoot: string, batchId: string): ProcessBatchBuildLayout;
+declare function normalizeItems(value: unknown, manifestDir: string, batchRoot: string): ProcessBatchBuildManifestItem[];
+export declare function normalizeProcessBatchBuildRequest(input: unknown, options: {
+    inputPath: string;
+    outDir?: string | null;
+    now?: Date;
+}): NormalizedProcessBatchBuildRequest;
+declare function buildInvocationIndex(normalized: NormalizedProcessBatchBuildRequest, options: RunProcessBatchBuildOptions, layout: ProcessBatchBuildLayout, now: Date): JsonRecord;
+declare function buildNextActions(layout: ProcessBatchBuildLayout): string[];
+declare function buildReport(normalized: NormalizedProcessBatchBuildRequest, layout: ProcessBatchBuildLayout, items: ProcessBatchBuildItemReport[], now: Date): ProcessBatchBuildReport;
+export declare function runProcessBatchBuild(options: RunProcessBatchBuildOptions): Promise<ProcessBatchBuildReport>;
+export declare const __testInternals: {
+    buildLayout: typeof buildLayout;
+    resolveBatchRoot: typeof resolveBatchRoot;
+    normalizeItems: typeof normalizeItems;
+    normalizeProcessBatchBuildRequest: typeof normalizeProcessBatchBuildRequest;
+    buildInvocationIndex: typeof buildInvocationIndex;
+    buildNextActions: typeof buildNextActions;
+    buildReport: typeof buildReport;
+};
+export {};

package/dist/src/lib/process-dedup-review.d.ts

@@ -0,0 +1,253 @@
+import type { FetchLike, ResponseLike } from './http.js';
+type JsonRecord = Record<string, unknown>;
+type ProcessGroupId = string | number;
+type ExchangeSummaryRow = {
+    exchange_internal_id: string;
+    flow_id: string;
+    flow_version: string;
+    direction: string;
+    mean_amount: string;
+    resulting_amount: string;
+    flow_short_description_en: string;
+    flow_short_description_zh: string;
+};
+type DedupInputProcess = {
+    process_id: string;
+    version: string;
+    name_en: string;
+    name_zh: string;
+    exchange_count: number | null;
+    overview_fingerprint: string;
+    sheet_exchange_rows: ExchangeSummaryRow[];
+};
+type DedupInputGroup = {
+    group_id: ProcessGroupId;
+    processes: DedupInputProcess[];
+};
+type RemoteMetadataRecord = {
+    process_id: string;
+    version: string;
+    state_code: number | null;
+    created_at: string | null;
+    modified_at: string | null;
+    user_id: string | null;
+    team_id: string | null;
+    model_id: string | null;
+    remote_name_en: string;
+    remote_name_zh: string;
+    remote_exchanges: ExchangeSummaryRow[];
+};
+type ReferenceHitRecord = {
+    id: string;
+    version: string;
+    state_code: number | null;
+    model_id?: string | null;
+};
+type ReferenceHits = {
+    processes: Record<string, ReferenceHitRecord[]>;
+    lifecyclemodels: Record<string, ReferenceHitRecord[]>;
+};
+type RemoteStatus = {
+    enabled: boolean;
+    loaded: number;
+    error: string | null;
+    reference_scan: 'not_run' | 'skipped_by_flag' | 'skipped_missing_user_id' | 'current_user_completed' | 'failed';
+};
+type ProcessDedupGate = {
+    status: 'passed' | 'blocked';
+    ruleset_id: 'process-dedup/default';
+    ruleset_version: '1';
+    ruleset_source_version: string;
+    ruleset_rule_ids: string[];
+    counts: {
+        duplicate_groups: number;
+        blocker_groups: number;
+    };
+    blockers: Array<{
+        group_id: ProcessGroupId;
+        code: 'process_exact_duplicate_fingerprint';
+        methodology_rule_id: string | null;
+        severity: 'blocker';
+        message: string;
+    }>;
+    next_action: 'continue' | 'resolve_duplicate_processes';
+};
+type DedupAnalyzedProcess = DedupInputProcess & Partial<RemoteMetadataRecord> & {
+    analysis_exchanges: ExchangeSummaryRow[];
+    normalized_exchange_signature: Array<[string, string, string, string]>;
+    name_score: number;
+    name_score_reasons: string[];
+};
+export type ProcessDedupReviewGroup = {
+    group_id: ProcessGroupId;
+    group_pattern: string;
+    exact_duplicate: boolean;
+    rule_id?: 'process_exact_duplicate_fingerprint';
+    methodology_rule_id?: string | null;
+    severity?: 'blocker';
+    blocker?: boolean;
+    processes: DedupAnalyzedProcess[];
+};
+type DeletePlanGroup = {
+    group_id: ProcessGroupId;
+    status: 'priority_delete_candidates';
+    confidence: 'high' | 'medium' | 'low';
+    current_user_reference_hits: {
+        keep_process_refs: number;
+        keep_lifecyclemodel_refs: number;
+        delete_refs: Record<string, {
+            process_refs: number;
+            lifecyclemodel_refs: number;
+        }>;
+    };
+    keep: {
+        process_id: string;
+        name_en: string;
+        name_zh: string;
+        score: number;
+        reasons: string[];
+    };
+    delete: Array<{
+        process_id: string;
+        name_en: string;
+        name_zh: string;
+        score: number;
+        reasons: string[];
+    }>;
+    notes: string[];
+};
+type RemoteAuthContext = {
+    projectBaseUrl: string;
+    publishableKey: string;
+    accessToken: string;
+    userId: string | null;
+};
+export type RunProcessDedupReviewOptions = {
+    inputPath: string;
+    outDir: string;
+    skipRemote?: boolean;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+    maxRetries?: number;
+    now?: Date;
+};
+export type ProcessDedupReviewReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'completed_process_dedup_review';
+    input_file: string;
+    out_dir: string;
+    source_label: string;
+    group_count: number;
+    exact_duplicate_group_count: number;
+    ruleset_id?: 'process-dedup/default';
+    ruleset_version?: '1';
+    ruleset_source_version?: string;
+    ruleset_rule_ids?: string[];
+    gate?: ProcessDedupGate;
+    remote_status: RemoteStatus;
+    files: {
+        input_manifest: string;
+        remote_metadata: string | null;
+        duplicate_groups: string;
+        delete_plan: string;
+        current_user_reference_scan: string | null;
+    };
+};
+declare function errorMessage(error: unknown): string;
+declare function normalizeAmount(value: unknown): string;
+declare function getLangList(value: unknown): JsonRecord[];
+declare function getLangText(value: unknown, lang: string): string;
+declare function normalizeExchangeRows(value: unknown): ExchangeSummaryRow[];
+declare function normalizeInputDocument(value: unknown, resolvedInputPath: string): {
+    sourceLabel: string;
+    groups: DedupInputGroup[];
+};
+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 fetchCurrentUserId(options: {
+    projectBaseUrl: string;
+    publishableKey: string;
+    accessToken: string;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    maxRetries: number;
+}): Promise<string | null>;
+declare function resolveRemoteAuthContext(options: {
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    maxRetries: number;
+    now: Date;
+}): Promise<RemoteAuthContext>;
+declare function fetchRemoteMetadata(options: {
+    processIds: string[];
+    auth: RemoteAuthContext;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    maxRetries: number;
+}): Promise<Record<string, RemoteMetadataRecord>>;
+declare function fetchCurrentUserRows(options: {
+    auth: RemoteAuthContext;
+    tableName: 'processes' | 'lifecyclemodels';
+    userId: string;
+    select: string;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    maxRetries: number;
+}): Promise<unknown[]>;
+declare function collectReferenceHits(root: unknown, targetIds: Set<string>): string[];
+declare function fetchCurrentUserReferenceHits(options: {
+    auth: RemoteAuthContext;
+    userId: string;
+    targetProcessIds: string[];
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    maxRetries: number;
+}): Promise<ReferenceHits>;
+declare function normalizedSignature(exchanges: ExchangeSummaryRow[]): Array<[string, string, string, string]>;
+declare function detectGroupPattern(processes: DedupAnalyzedProcess[]): string;
+declare function scoreProcessName(process: Pick<DedupAnalyzedProcess, 'name_en' | 'name_zh' | 'remote_name_en' | 'remote_name_zh'>, groupPattern: string): {
+    score: number;
+    reasons: string[];
+};
+declare function analyzeGroups(groups: DedupInputGroup[], remoteById: Record<string, RemoteMetadataRecord>, referenceHits: ReferenceHits): {
+    duplicateGroups: ProcessDedupReviewGroup[];
+    deletePlanGroups: DeletePlanGroup[];
+};
+declare function buildDedupGate(duplicateGroups: ProcessDedupReviewGroup[]): ProcessDedupGate;
+export declare function runProcessDedupReview(options: RunProcessDedupReviewOptions): Promise<ProcessDedupReviewReport>;
+export declare const __testInternals: {
+    analyzeGroups: typeof analyzeGroups;
+    buildDedupGate: typeof buildDedupGate;
+    collectReferenceHits: typeof collectReferenceHits;
+    detectGroupPattern: typeof detectGroupPattern;
+    errorMessage: typeof errorMessage;
+    fetchCurrentUserId: typeof fetchCurrentUserId;
+    fetchCurrentUserReferenceHits: typeof fetchCurrentUserReferenceHits;
+    fetchCurrentUserRows: typeof fetchCurrentUserRows;
+    fetchJsonWithRetry: typeof fetchJsonWithRetry;
+    fetchRemoteMetadata: typeof fetchRemoteMetadata;
+    getLangList: typeof getLangList;
+    getLangText: typeof getLangText;
+    normalizeAmount: typeof normalizeAmount;
+    normalizeExchangeRows: typeof normalizeExchangeRows;
+    normalizeInputDocument: typeof normalizeInputDocument;
+    normalizedSignature: typeof normalizedSignature;
+    parseJsonResponse: typeof parseJsonResponse;
+    resolveRemoteAuthContext: typeof resolveRemoteAuthContext;
+    scoreProcessName: typeof scoreProcessName;
+};
+export {};

package/dist/src/lib/process-flow-build-plan.d.ts

@@ -0,0 +1,108 @@
+import { type JsonObject } from './dataset-local.js';
+import { type SafeParseSchema } from './tidas-sdk-validation.js';
+type BuildPlanKind = 'process' | 'flow';
+type BuildPlanAction = 'validate' | 'materialize';
+type BuildPlanStatus = 'passed' | 'blocked';
+type BuildPlanDecision = 'reuse' | 'update_same_row' | 'version_bump' | 'create_new' | 'block_duplicate' | 'manual_review';
+type UnitOfAnalysisDecision = 'ready_for_materialization' | 'declared_unit_dataset' | 'blocked_until_scaling_evidence' | 'manual_review';
+type GateFinding = {
+    code: string;
+    severity: 'info' | 'warning' | 'blocker';
+    message: string;
+    path?: string;
+};
+type SchemaValidationSummary = {
+    status: 'passed' | 'failed' | 'not_applicable';
+    validator: string | null;
+    issue_count: number;
+    issues: Array<{
+        path: string;
+        message: string;
+        code: string;
+    }>;
+};
+type BuildPlanRequiredFields = {
+    required: string[];
+    satisfied: string[];
+    missing: string[];
+};
+type BuildPlanFiles = {
+    gate_report: string | null;
+    materialized_artifact: string | null;
+};
+export type BuildPlanGateReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    kind: BuildPlanKind;
+    action: BuildPlanAction;
+    status: BuildPlanStatus;
+    ruleset_id: string;
+    ruleset_version: string;
+    input_path: string;
+    out_dir: string | null;
+    report_only: boolean;
+    inputs: {
+        plan_schema_version: number | string | null;
+        identity_decision: BuildPlanDecision | null;
+        unit_of_analysis_decision: UnitOfAnalysisDecision | null;
+    };
+    required_fields: BuildPlanRequiredFields;
+    schema_validation: SchemaValidationSummary;
+    findings: GateFinding[];
+    blockers: GateFinding[];
+    next_action: 'materialize_payload' | 'use_materialized_artifact' | 'fix_build_plan';
+    files: BuildPlanFiles;
+};
+export type RunBuildPlanOptions = {
+    inputPath: string;
+    outDir?: string | null;
+    reportOnly?: boolean;
+    rawInput?: unknown;
+    now?: Date;
+    schemas?: Partial<Record<BuildPlanKind, SafeParseSchema>>;
+};
+export type RunProcessBuildPlanValidateOptions = RunBuildPlanOptions;
+export type RunProcessBuildPlanMaterializeOptions = RunBuildPlanOptions;
+export type RunFlowBuildPlanValidateOptions = RunBuildPlanOptions;
+export type RunFlowBuildPlanMaterializeOptions = RunBuildPlanOptions;
+export type ProcessBuildPlanGateReport = BuildPlanGateReport & {
+    kind: 'process';
+};
+export type FlowBuildPlanGateReport = BuildPlanGateReport & {
+    kind: 'flow';
+};
+type Evaluation = {
+    plan: JsonObject;
+    findings: GateFinding[];
+    blockers: GateFinding[];
+    requiredFields: BuildPlanRequiredFields;
+    decision: BuildPlanDecision | null;
+    unitOfAnalysisDecision: UnitOfAnalysisDecision | null;
+};
+declare function loadBuildPlan(inputPath: string, rawInput: unknown): JsonObject;
+declare function multiLangFromValue(value: unknown, fallback: string, fallbackLang?: string): JsonObject[];
+declare function buildAnnualSupply(plan: JsonObject, referenceExchange: JsonObject): JsonObject[];
+declare function buildCanonicalFlowPayload(plan: JsonObject, inputPath: string): JsonObject;
+declare function buildCanonicalProcessPayload(plan: JsonObject, inputPath: string): JsonObject;
+declare function evidenceBindingPaths(plan: JsonObject): Set<string>;
+declare function decisionFromPlan(plan: JsonObject): BuildPlanDecision | null;
+declare function evaluateBuildPlan(plan: JsonObject, kind: BuildPlanKind): Evaluation;
+declare function validateMaterializedSchema(artifact: JsonObject, kind: BuildPlanKind, schemas: Partial<Record<BuildPlanKind, SafeParseSchema>> | undefined): SchemaValidationSummary;
+declare function materializePlan(plan: JsonObject, kind: BuildPlanKind, inputPath: string): JsonObject;
+export declare function runProcessBuildPlanValidate(options: RunProcessBuildPlanValidateOptions): Promise<ProcessBuildPlanGateReport>;
+export declare function runProcessBuildPlanMaterialize(options: RunProcessBuildPlanMaterializeOptions): Promise<ProcessBuildPlanGateReport>;
+export declare function runFlowBuildPlanValidate(options: RunFlowBuildPlanValidateOptions): Promise<FlowBuildPlanGateReport>;
+export declare function runFlowBuildPlanMaterialize(options: RunFlowBuildPlanMaterializeOptions): Promise<FlowBuildPlanGateReport>;
+export declare const __testInternals: {
+    decisionFromPlan: typeof decisionFromPlan;
+    evidenceBindingPaths: typeof evidenceBindingPaths;
+    evaluateBuildPlan: typeof evaluateBuildPlan;
+    loadBuildPlan: typeof loadBuildPlan;
+    materializePlan: typeof materializePlan;
+    validateMaterializedSchema: typeof validateMaterializedSchema;
+    buildCanonicalFlowPayload: typeof buildCanonicalFlowPayload;
+    buildCanonicalProcessPayload: typeof buildCanonicalProcessPayload;
+    buildAnnualSupply: typeof buildAnnualSupply;
+    multiLangFromValue: typeof multiLangFromValue;
+};
+export {};

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

@@ -0,0 +1,26 @@
+import type { FetchLike } from './http.js';
+import { type SupabaseProcessLookup } from './supabase-rest.js';
+type JsonObject = Record<string, unknown>;
+export type RunProcessGetOptions = {
+    processId: string;
+    version?: string | null;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+    now?: Date;
+};
+export type ProcessGetReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'resolved_remote_process';
+    process_id: string;
+    requested_version: string | null;
+    resolved_version: string;
+    resolution: SupabaseProcessLookup['resolution'];
+    source_url: string;
+    modified_at: string | null;
+    state_code: number | null;
+    process: JsonObject;
+};
+export declare function runProcessGet(options: RunProcessGetOptions): Promise<ProcessGetReport>;
+export {};