@tiangong-lca/cli 0.1.1 → 0.1.2

package/dist/src/lib/identity-preflight.d.ts

@@ -0,0 +1,235 @@
+import type { FetchLike } from './http.js';
+import { type JsonObject } from './dataset-local.js';
+import { type SafeParseSchema, type SdkValidationFactory } from './tidas-sdk-validation.js';
+type IdentityPreflightKind = 'process' | 'flow';
+export type IdentityPreflightDecision = 'reuse' | 'update_same_row' | 'version_bump' | 'create_new' | 'block_duplicate' | 'manual_review';
+export type IdentityPreflightStatus = 'passed' | 'blocked' | 'needs_review';
+export type IdentityPreflightFinding = {
+    code: string;
+    severity: 'info' | 'warning' | 'blocker';
+    message: string;
+    candidate_index?: number;
+};
+type ValidationSummary = {
+    status: 'passed' | 'failed' | 'not_applicable';
+    validator: string | null;
+    issue_count: number;
+    issues: Array<{
+        path: string;
+        message: string;
+        code: string;
+    }>;
+};
+type IdentityProfile = {
+    id: string | null;
+    version: string | null;
+    state_code: number | null;
+    names: string[];
+    normalized_names: string[];
+    identity_key: string;
+    exchange_signature: string[];
+    fields: Record<string, string | null | string[]>;
+};
+export type IdentityPreflightCandidateReport = {
+    index: number;
+    id: string | null;
+    version: string | null;
+    state_code: number | null;
+    names: string[];
+    fields: Record<string, string | null | string[]>;
+    exchange_signature: string[];
+    identity_key: string;
+    match_score: number;
+    match_reasons: string[];
+    decision_hint: IdentityPreflightDecision | null;
+};
+export type IdentityPreflightCandidateSourceReport = {
+    path: string;
+    kind: 'embedded_request' | 'file' | 'directory' | 'remote_search';
+    row_count: number;
+    scanned_files: string[];
+    endpoint?: string;
+    query?: string;
+    filter?: JsonObject | null;
+    options?: JsonObject | null;
+};
+export type IdentityPreflightReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    kind: IdentityPreflightKind;
+    status: IdentityPreflightStatus;
+    decision: IdentityPreflightDecision;
+    confidence: 'high' | 'medium' | 'low';
+    input_path: string;
+    out_dir: string | null;
+    target: {
+        id: string | null;
+        version: string | null;
+        names: string[];
+        fields: Record<string, string | null | string[]>;
+        identity_key: string;
+        exchange_signature: string[];
+        schema_validation: ValidationSummary;
+    };
+    candidates: IdentityPreflightCandidateReport[];
+    candidate_sources: IdentityPreflightCandidateSourceReport[];
+    findings: IdentityPreflightFinding[];
+    blockers: IdentityPreflightFinding[];
+    next_action: 'reuse_existing' | 'repair_existing_draft' | 'prepare_version_update' | 'materialize_new_payload' | 'stop_duplicate' | 'queue_manual_review';
+    files: {
+        identity_decision: string | null;
+        candidates: string | null;
+        candidate_sources: string | null;
+    };
+};
+export type RunIdentityPreflightOptions = {
+    inputPath: string;
+    outDir?: string | null;
+    rawInput?: unknown;
+    candidateInputPaths?: string[];
+    remoteCandidateSearch?: boolean;
+    remoteQuery?: string | null;
+    remoteFilter?: JsonObject | null;
+    remoteLimit?: number | null;
+    remoteDataSource?: string | null;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+    now?: Date;
+    schemas?: Partial<Record<IdentityPreflightKind, SafeParseSchema>>;
+};
+export type RunProcessIdentityPreflightOptions = RunIdentityPreflightOptions;
+export type RunFlowIdentityPreflightOptions = RunIdentityPreflightOptions;
+export type ProcessIdentityPreflightReport = IdentityPreflightReport & {
+    kind: 'process';
+};
+export type FlowIdentityPreflightReport = IdentityPreflightReport & {
+    kind: 'flow';
+};
+type NormalizedInput = {
+    target: JsonObject;
+    candidates: JsonObject[];
+    candidateInputPaths: string[];
+    remoteCandidateSearch: RemoteCandidateSearchConfig;
+};
+type CandidateEvaluation = {
+    report: IdentityPreflightCandidateReport;
+    findings: IdentityPreflightFinding[];
+};
+type RemoteCandidateSearchConfig = {
+    enabled: boolean;
+    query: string | null;
+    filter: JsonObject | null;
+    profileHints: JsonObject | null;
+    limit: number | null;
+    dataSource: string | null;
+    matchThreshold: number | null;
+    lexicalWeight: number | null;
+    semanticWeight: number | null;
+    rrfK: number | null;
+    pageSize: number | null;
+    pageCurrent: number | null;
+};
+declare function normalizePositiveInteger(value: unknown, label: string): number | null;
+declare function normalizeNonNegativeNumber(value: unknown, label: string): number | null;
+declare function normalizeMatchThreshold(value: unknown): number | null;
+declare function normalizeRemoteCandidateSearch(value: unknown): RemoteCandidateSearchConfig;
+declare function normalizePreflightInput(rawInput: unknown, kind: IdentityPreflightKind): NormalizedInput;
+interface CandidateInputStats {
+    isFile(): boolean;
+    isDirectory(): boolean;
+}
+declare function collectCandidateFilesFromStats(resolved: string, stats: CandidateInputStats): string[];
+declare function readCandidateSource(candidatePath: string): {
+    rows: JsonObject[];
+    source: IdentityPreflightCandidateSourceReport;
+};
+declare function mergeRemoteCandidateSearchConfig(inputConfig: RemoteCandidateSearchConfig, options: RunIdentityPreflightOptions): RemoteCandidateSearchConfig;
+declare function isRemoteQueryNoiseText(value: string): boolean;
+declare function queryFieldValues(value: string | null | string[], limit?: number): string[];
+declare function appendQueryLine(lines: string[], label: string, value: string | null | string[], limit?: number): void;
+declare function exchangeFlowRefsFromSignature(signature: string[]): string[];
+declare function compactRemoteQuery(lines: string[], fallback: string): string | null;
+declare function defaultRemoteQuery(profile: IdentityProfile): string | null;
+declare function remoteSearchFilter(kind: IdentityPreflightKind, profile: IdentityProfile, explicitFilter: JsonObject | null): JsonObject | null;
+declare function remoteSearchOptions(config: RemoteCandidateSearchConfig): JsonObject | null;
+declare function rowsFromRemoteSearchResponse(value: unknown): JsonObject[];
+declare function schemaForKind(kind: IdentityPreflightKind, schemas: Partial<Record<IdentityPreflightKind, SafeParseSchema>> | undefined): {
+    validator: string;
+    schema: SafeParseSchema;
+    createEntity: SdkValidationFactory | null;
+};
+declare function processReferenceExchange(root: JsonObject): JsonObject | null;
+declare function processReferenceFlowValues(root: JsonObject): {
+    ids: string[];
+    names: string[];
+};
+declare function processProfile(row: JsonObject): IdentityProfile;
+declare function flowProfile(row: JsonObject): IdentityProfile;
+declare function identityKeyFromProfile(kind: IdentityPreflightKind, names: string[], fields: Record<string, string | null | string[]>, exchangeSignature: string[]): string;
+declare function applyIdentityProfileHints(profile: IdentityProfile, hints: JsonObject | null, kind: IdentityPreflightKind): IdentityProfile;
+declare function profileForKind(row: JsonObject, kind: IdentityPreflightKind): IdentityProfile;
+declare function expandedFlowNameVariants(value: string): string[];
+declare function flowNameVariants(names: string[]): string[];
+declare function nameTokens(names: string[]): Set<string>;
+declare function tokenOverlapRatio(left: Set<string>, right: Set<string>): number;
+declare function tokenCoverageRatio(left: Set<string>, right: Set<string>): number;
+declare function hasConflictingFlowName(target: IdentityProfile, candidate: IdentityProfile): boolean;
+declare function sameNonEmptyField(left: string | null | string[], right: string | null | string[]): boolean;
+declare function sameCasField(left: string | null | string[], right: string | null | string[]): boolean;
+declare function elementaryCompartmentKey(value: string): string | null;
+declare function sameElementaryCompartment(left: string | null | string[], right: string | null | string[]): boolean;
+declare function candidateEvaluation(target: IdentityProfile, candidate: IdentityProfile, kind: IdentityPreflightKind, index: number): CandidateEvaluation;
+declare function chooseDecision(evaluations: CandidateEvaluation[], validation: ValidationSummary, kind: IdentityPreflightKind): {
+    decision: IdentityPreflightDecision;
+    confidence: 'high' | 'medium' | 'low';
+    findings: IdentityPreflightFinding[];
+};
+declare function statusForDecision(decision: IdentityPreflightDecision, blockers: IdentityPreflightFinding[]): IdentityPreflightStatus;
+declare function nextActionForDecision(decision: IdentityPreflightDecision): IdentityPreflightReport['next_action'];
+export declare function runIdentityPreflight(kind: IdentityPreflightKind, options: RunIdentityPreflightOptions): Promise<IdentityPreflightReport>;
+export declare function runProcessIdentityPreflight(options: RunProcessIdentityPreflightOptions): Promise<ProcessIdentityPreflightReport>;
+export declare function runFlowIdentityPreflight(options: RunFlowIdentityPreflightOptions): Promise<FlowIdentityPreflightReport>;
+export declare const __testInternals: {
+    appendQueryLine: typeof appendQueryLine;
+    applyIdentityProfileHints: typeof applyIdentityProfileHints;
+    candidateEvaluation: typeof candidateEvaluation;
+    chooseDecision: typeof chooseDecision;
+    collectCandidateFilesFromStats: typeof collectCandidateFilesFromStats;
+    compactRemoteQuery: typeof compactRemoteQuery;
+    defaultRemoteQuery: typeof defaultRemoteQuery;
+    elementaryCompartmentKey: typeof elementaryCompartmentKey;
+    entityFactoryExports: Record<IdentityPreflightKind, "CAS_NUMBER_CHECKSUM_ERROR_CODE" | "CAS_NUMBER_PATTERN" | "CHINESE_CHARACTER_RE" | "ContactCategorySchema" | "ContactSchema" | "DEFAULT_VALIDATION_CONFIG" | "DEFAULT_XML_PARSE_OPTIONS" | "DEFAULT_XML_UNPARSE_OPTIONS" | "ErrorSeverity" | "FlowElementaryCategorySchema" | "FlowProductCategorySchema" | "FlowPropertyCategorySchema" | "FlowPropertySchema" | "FlowSchema" | "LCIAMethodCategorySchema" | "LCIAMethodSchema" | "LifeCycleModelSchema" | "LocationCategorySchema" | "ProcessCategorySchema" | "ProcessSchema" | "SUPPORTED_CATEGORIES" | "SourceCategorySchema" | "SourceSchema" | "TIDAS_LANGUAGE_CODES" | "TIDAS_LANGUAGE_CODE_SET" | "TidasContact" | "TidasEntity" | "TidasFlow" | "TidasFlowProperty" | "TidasLCIAMethod" | "TidasLifeCycleModel" | "TidasProcess" | "TidasSource" | "TidasUnitGroup" | "UnitGroupCategorySchema" | "UnitGroupSchema" | "ValidationUtils" | "batchSuggest" | "buildCategoryReport" | "buildPackageReport" | "categoryValidate" | "collectClassificationIssues" | "collectFlowSchemaGapIssues" | "collectLocalizedTextIssues" | "compareMethodologyWithSchema" | "convertDirectory" | "convertFormat" | "copyEilcdAssets" | "copyRuntimeAssetDir" | "copyTidasAssets" | "createContact" | "createContactFromJSON" | "createContactsBatch" | "createFlow" | "createFlowFromJSON" | "createFlowPropertiesBatch" | "createFlowProperty" | "createFlowPropertyFromJSON" | "createFlowsBatch" | "createLCIAMethod" | "createLCIAMethodFromJSON" | "createLCIAMethodsBatch" | "createLifeCycleModel" | "createLifeCycleModelFromJSON" | "createLifeCycleModelsBatch" | "createProcess" | "createProcessFromJSON" | "createProcessesBatch" | "createSource" | "createSourceFromJSON" | "createSourcesBatch" | "createStaticValidationMethod" | "createTidasEntity" | "createUnitGroup" | "createUnitGroupFromJSON" | "createUnitGroupsBatch" | "createValidationMethod" | "datasetFromXml" | "datasetToXml" | "deepClone" | "default" | "extractMethodologyPaths" | "extractSchemaPaths" | "get" | "getAvailableDataTypes" | "getAvailableTidasContractKinds" | "getGlobalValidationConfig" | "getGlobalValidationMode" | "getTidasContractPack" | "getTidasMethodologyData" | "getTidasMethodologyText" | "getTidasRuntimeRuleset" | "getTidasSchemaData" | "getTidasSchemaText" | "globalConfig" | "isValidCASNumber" | "loadConfigFromEnvironment" | "merge" | "normalizeMethodologyPath" | "normalizeTidasContractKind" | "parseWithZod" | "parseXml" | "resetGlobalConfig" | "resolveRuntimeAssetDir" | "resolveRuntimeAssetsDir" | "set" | "setGlobalValidationConfig" | "setGlobalValidationMode" | "suggestData" | "suggestRawData" | "summarizeIssues" | "unparseXml" | "updatePath" | "validateBatch" | "validateBundledMethodologies" | "validateElementaryFlowsClassificationHierarchy" | "validateLocalizedTextLanguageConstraints" | "validateMethodologySchemaParity" | "validatePackageDir" | "validateProcessesClassificationHierarchy" | "validateProductFlowsClassificationHierarchy" | "validateSourcesClassificationHierarchy" | "validateSuggestionApiKey" | "validateWithZod">;
+    exchangeFlowRefsFromSignature: typeof exchangeFlowRefsFromSignature;
+    expandedFlowNameVariants: typeof expandedFlowNameVariants;
+    flowNameVariants: typeof flowNameVariants;
+    flowProfile: typeof flowProfile;
+    hasConflictingFlowName: typeof hasConflictingFlowName;
+    identityKeyFromProfile: typeof identityKeyFromProfile;
+    isRemoteQueryNoiseText: typeof isRemoteQueryNoiseText;
+    mergeRemoteCandidateSearchConfig: typeof mergeRemoteCandidateSearchConfig;
+    nameTokens: typeof nameTokens;
+    nextActionForDecision: typeof nextActionForDecision;
+    normalizeMatchThreshold: typeof normalizeMatchThreshold;
+    normalizeNonNegativeNumber: typeof normalizeNonNegativeNumber;
+    normalizePreflightInput: typeof normalizePreflightInput;
+    normalizeRemoteCandidateSearch: typeof normalizeRemoteCandidateSearch;
+    normalizePositiveInteger: typeof normalizePositiveInteger;
+    processProfile: typeof processProfile;
+    processReferenceExchange: typeof processReferenceExchange;
+    processReferenceFlowValues: typeof processReferenceFlowValues;
+    profileForKind: typeof profileForKind;
+    queryFieldValues: typeof queryFieldValues;
+    readCandidateSource: typeof readCandidateSource;
+    remoteSearchOptions: typeof remoteSearchOptions;
+    remoteSearchFilter: typeof remoteSearchFilter;
+    rowsFromRemoteSearchResponse: typeof rowsFromRemoteSearchResponse;
+    sameCasField: typeof sameCasField;
+    sameElementaryCompartment: typeof sameElementaryCompartment;
+    sameNonEmptyField: typeof sameNonEmptyField;
+    schemaForKind: typeof schemaForKind;
+    statusForDecision: typeof statusForDecision;
+    tokenCoverageRatio: typeof tokenCoverageRatio;
+    tokenOverlapRatio: typeof tokenOverlapRatio;
+};
+export {};

package/dist/src/lib/io.d.ts

@@ -0,0 +1,2 @@
+export declare function readJsonInput(inputPath: string): unknown;
+export declare function stringifyJson(value: unknown, compact: boolean): string;

package/dist/src/lib/kb-search.d.ts

@@ -0,0 +1,23 @@
+import type { EnvSpec } from './env.js';
+import type { FetchLike } from './http.js';
+export declare const KB_SEARCH_ENV_KEYS: {
+    readonly apiBaseUrl: 'TIANGONG_LCA_KB_SEARCH_API_BASE_URL';
+    readonly apiKey: 'TIANGONG_LCA_KB_SEARCH_API_KEY';
+    readonly region: 'TIANGONG_LCA_KB_SEARCH_REGION';
+};
+export declare const KB_SEARCH_ENV_SPECS: EnvSpec[];
+export type KbSearchCorpus = 'esg' | 'sci' | 'patent' | 'report' | 'standard' | 'textbook';
+export type KbSearchRuntimeEnv = {
+    apiBaseUrl: string | null;
+    apiKey: string | null;
+    region: string | null;
+};
+export type ExecuteKbSearchOptions = {
+    corpus: KbSearchCorpus;
+    payload: unknown;
+    env: KbSearchRuntimeEnv;
+    timeoutMs: number;
+    fetchImpl: FetchLike;
+};
+export declare function readKbSearchRuntimeEnv(env: NodeJS.ProcessEnv): KbSearchRuntimeEnv;
+export declare function executeKbSearch(options: ExecuteKbSearchOptions): Promise<unknown>;

package/dist/src/lib/lca-release.d.ts

@@ -0,0 +1,105 @@
+import type { FetchLike, ResponseLike } from './http.js';
+import { requireSupabaseRestRuntime } from './supabase-client.js';
+export declare const LCA_RELEASE_ACTIONS: readonly ['prepare', 'upload', 'finalize', 'approve', 'publish', 'readback-verify', 'unpublish', 'status', 'current', 'calculation-bundle', 'calculation-artifact', 'artifact-download'];
+export type LcaReleaseAction = (typeof LCA_RELEASE_ACTIONS)[number];
+export type LcaReleaseOutput = {
+    path: string;
+    sha256: string;
+    byteSize: number;
+    mediaType: string;
+};
+export type LcaReleaseReport = {
+    schemaVersion: 'tiangong.cli.lca-release.v1';
+    action: LcaReleaseAction;
+    status: 'planned' | 'completed';
+    complete: boolean;
+    summary: Record<string, unknown>;
+    data?: unknown;
+    output?: LcaReleaseOutput;
+    request?: Record<string, unknown>;
+    warnings: string[];
+    nextCommands: string[];
+};
+export type RunLcaReleaseOptions = {
+    action: LcaReleaseAction;
+    inputPath: string | null;
+    outputPath: string | null;
+    releaseRunId: string | null;
+    packageId: string | null;
+    artifactId: string | null;
+    artifactPath: string | null;
+    env: NodeJS.ProcessEnv;
+    timeoutMs: number;
+    dryRun: boolean;
+    force: boolean;
+    fetchImpl: FetchLike;
+};
+type JsonRecord = Record<string, unknown>;
+type LocalUploadArtifact = {
+    profileId: string;
+    format: string;
+    sha256: string;
+    byteSize: number;
+    mediaType: string;
+    filePath: string;
+};
+declare function isRecord(value: unknown): value is JsonRecord;
+declare function requiredString(value: unknown, field: string): string;
+declare function requiredId(value: string | null, flag: string): string;
+declare function requiredPath(value: string | null, flag: string): string;
+declare function sha256Bytes(bytes: Uint8Array): string;
+declare function outputRef(outputPath: string, bytes: Uint8Array, mediaType: string): LcaReleaseOutput;
+declare function writeOutput(outputPath: string, bytes: Uint8Array, mediaType: string, force: boolean): LcaReleaseOutput;
+declare function writeJsonOutput(outputPath: string, value: unknown, force: boolean): LcaReleaseOutput;
+declare function commandAction(action: LcaReleaseAction): string;
+declare function buildCommandPayload(options: RunLcaReleaseOptions, userApiKey: string): {
+    body: JsonRecord;
+    inputPath: string | null;
+};
+declare function edgeUrl(apiBaseUrl: string): string;
+declare function readJsonResponse(response: ResponseLike, url: string): Promise<JsonRecord>;
+declare function invokeCommand(options: {
+    url: string;
+    publishableKey: string;
+    accessToken: string;
+    body: JsonRecord;
+    timeoutMs: number;
+    fetchImpl: FetchLike;
+}): Promise<JsonRecord>;
+declare function parseLocalUploadArtifacts(value: JsonRecord, inputPath: string): LocalUploadArtifact[];
+declare function parseUploadResponse(payload: JsonRecord, local: LocalUploadArtifact[]): {
+    local: LocalUploadArtifact;
+    storageBucket: string;
+    objectKey: string;
+    token: string;
+}[];
+declare function runUpload(options: RunLcaReleaseOptions, runtime: ReturnType<typeof requireSupabaseRestRuntime>, url: string): Promise<LcaReleaseReport>;
+declare function downloadBytes(signedUrl: string, timeoutMs: number, fetchImpl: FetchLike): Promise<Uint8Array>;
+declare function selectDownload(action: 'artifact-download' | 'calculation-artifact', data: unknown, artifactPath: string | null): JsonRecord;
+declare function nextCommands(action: LcaReleaseAction, data: unknown): string[];
+declare function summarize(action: LcaReleaseAction, data: unknown): Record<string, unknown>;
+export declare function runLcaRelease(options: RunLcaReleaseOptions): Promise<LcaReleaseReport>;
+export declare function renderLcaReleaseReport(report: LcaReleaseReport): string;
+export declare const __testInternals: {
+    buildCommandPayload: typeof buildCommandPayload;
+    commandAction: typeof commandAction;
+    downloadBytes: typeof downloadBytes;
+    edgeUrl: typeof edgeUrl;
+    invokeCommand: typeof invokeCommand;
+    isRecord: typeof isRecord;
+    nextCommands: typeof nextCommands;
+    outputRef: typeof outputRef;
+    parseLocalUploadArtifacts: typeof parseLocalUploadArtifacts;
+    parseUploadResponse: typeof parseUploadResponse;
+    readJsonResponse: typeof readJsonResponse;
+    requiredId: typeof requiredId;
+    requiredPath: typeof requiredPath;
+    requiredString: typeof requiredString;
+    runUpload: typeof runUpload;
+    selectDownload: typeof selectDownload;
+    sha256Bytes: typeof sha256Bytes;
+    summarize: typeof summarize;
+    writeJsonOutput: typeof writeJsonOutput;
+    writeOutput: typeof writeOutput;
+};
+export {};

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

@@ -0,0 +1,223 @@
+import { type RunLayout } from './run.js';
+type JsonRecord = Record<string, unknown>;
+type LifecyclemodelAutoBuildStatus = 'completed_local_lifecyclemodel_auto_build_run';
+export type LifecyclemodelAutoBuildLayout = RunLayout & {
+    requestDir: string;
+    selectionDir: string;
+    discoveryDir: string;
+    modelsDir: string;
+    requestSnapshotPath: string;
+    normalizedRequestPath: string;
+    runPlanPath: string;
+    resolvedManifestPath: string;
+    selectionBriefPath: string;
+    referenceModelSummaryPath: string;
+    invocationIndexPath: string;
+    runManifestPath: string;
+    reportPath: string;
+};
+export type NormalizedLifecyclemodelAutoBuildRequest = {
+    schema_version: 1;
+    request_path: string;
+    run_id: string;
+    run_root: string;
+    manifest: JsonRecord;
+    local_runs: string[];
+};
+type ProcessRecord = {
+    processUuid: string;
+    version: string;
+    raw: JsonRecord;
+    referenceExchangeInternalId: string;
+    referenceFlowUuid: string;
+    referenceDirection: 'Input' | 'Output';
+    referenceAmount: number;
+    inputAmounts: Record<string, number>;
+    outputAmounts: Record<string, number>;
+    nameEn: string;
+    nameZh: string;
+    routeEn: string;
+    mixEn: string;
+    geographyCode: string;
+    classificationPath: string[];
+    tokenSet: Set<string>;
+    sourceKind: 'local_run_export';
+    sourceLabel: string;
+    includedProcessRefCount: number;
+};
+type Edge = {
+    src: string;
+    dst: string;
+    flowUuid: string;
+    downstreamInputAmount: number;
+    confidence: number;
+    reasons: string[];
+};
+export type LifecyclemodelAutoBuildLocalReport = {
+    run_dir: string;
+    run_name: string;
+    model_file: string;
+    summary_file: string;
+    connections_file: string;
+    process_catalog_file: string;
+    summary: JsonRecord;
+};
+export type LifecyclemodelAutoBuildReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: LifecyclemodelAutoBuildStatus;
+    request_path: string;
+    run_id: string;
+    run_root: string;
+    local_run_count: number;
+    built_model_count: number;
+    files: {
+        request_snapshot: string;
+        normalized_request: string;
+        run_plan: string;
+        resolved_manifest: string;
+        selection_brief: string;
+        reference_model_summary: string;
+        invocation_index: string;
+        run_manifest: string;
+        report: string;
+    };
+    local_build_reports: LifecyclemodelAutoBuildLocalReport[];
+    next_actions: string[];
+};
+export type RunLifecyclemodelAutoBuildOptions = {
+    inputPath: string;
+    outDir?: string | null;
+    now?: Date;
+    cwd?: string;
+    inputValue?: unknown;
+    runIdOverride?: string;
+};
+declare function ensureList<T = unknown>(value: unknown): T[];
+declare function copyJson<T>(value: T): T;
+declare function numberOrZero(value: unknown): number;
+declare function firstText(value: unknown): string;
+declare function langTextMap(value: unknown): Record<string, string>;
+declare function localizedText(value: unknown, preferred?: string): string;
+declare function multilangText(value: unknown): [string, string];
+declare function multilangFromText(enText: string, zhText?: string): Array<Record<string, string>>;
+declare function buildNameSummary(nameInfo: JsonRecord): Array<Record<string, string>>;
+declare function extractClassificationPath(classificationInfo: unknown): string[];
+declare function classificationOverlap(left: string[], right: string[]): number;
+declare function uuid5FromText(namespaceUuid: string, value: string): string;
+declare function formatNumber(value: number): string;
+declare function toJsonNumber(value: number): number;
+declare function deepMerge(base: unknown, override: unknown): unknown;
+declare function normalizeLocalRuns(value: unknown, requestDir: string): string[];
+declare function buildLayout(runRoot: string, runId: string): LifecyclemodelAutoBuildLayout;
+export declare function normalizeLifecyclemodelAutoBuildRequest(input: unknown, options: {
+    inputPath: string;
+    outDir?: string | null;
+    now?: Date;
+    runIdOverride?: string;
+}): NormalizedLifecyclemodelAutoBuildRequest;
+declare function buildSelectionBrief(manifest: JsonRecord): string;
+declare function buildReferenceModelSummary(manifest: JsonRecord): JsonRecord;
+declare function buildPlan(normalized: NormalizedLifecyclemodelAutoBuildRequest, layout: LifecyclemodelAutoBuildLayout, now: Date): JsonRecord;
+declare function extractFlowDatasetFromState(state: JsonRecord): JsonRecord;
+declare function resolvePublicationBlock(dataset: JsonRecord): JsonRecord;
+declare function loadProcessRecord(filePath: string, sourceKind: 'local_run_export', sourceLabel: string): ProcessRecord;
+declare function scoreEdgeCandidate(src: ProcessRecord, dst: ProcessRecord, flowUuid: string, downstreamAmount: number): {
+    confidence: number;
+    reasons: string[];
+};
+declare function inferEdges(processMap: Record<string, ProcessRecord>): Edge[];
+declare function chooseReferenceProcess(processMap: Record<string, ProcessRecord>, edges: Edge[], state: JsonRecord, preferredProcessIds: Set<string>): string;
+declare function collectReachable(finalProcessId: string, edges: Edge[]): Set<string>;
+declare function topologicalOrder(processIds: Set<string>, edges: Edge[]): string[];
+declare function computeMultiplicationFactors(processMap: Record<string, ProcessRecord>, reachable: Set<string>, edges: Edge[], order: string[], finalProcessId: string): Record<string, number>;
+declare function exchangeAmount(exchange: JsonRecord): number;
+declare function cloneExchangeWithAmount(exchange: JsonRecord, amount: number, internalId: string, quantitativeReference?: boolean): JsonRecord;
+declare function buildProcessInstances(processMap: Record<string, ProcessRecord>, order: string[], edges: Edge[], factors: Record<string, number>): {
+    processInstances: JsonRecord[];
+    internalIds: Record<string, string>;
+};
+declare function buildLifecycleModelDataset(runName: string, state: JsonRecord, processMap: Record<string, ProcessRecord>, order: string[], edges: Edge[], factors: Record<string, number>, finalProcessId: string): {
+    model: JsonRecord;
+    summary: JsonRecord;
+};
+export declare function runLifecyclemodelAutoBuild(options: RunLifecyclemodelAutoBuildOptions): Promise<LifecyclemodelAutoBuildReport>;
+export declare const __testInternals: {
+    DEFAULT_MANIFEST: {
+        readonly run_label: 'lifecyclemodel-automated-builder';
+        readonly allow_remote_write: false;
+        readonly discovery: {
+            readonly sources: readonly [{
+                readonly kind: 'account_processes';
+                readonly selector: 'all-accessible';
+            }, {
+                readonly kind: 'public_open_data';
+                readonly table: 'processes';
+                readonly filters: {
+                    readonly state_code: 100;
+                };
+            }];
+            readonly supporting_open_tables: readonly ['flows', 'sources', 'lifecyclemodels'];
+            readonly batch_limit: 200;
+            readonly reference_model_queries: readonly [];
+            readonly reference_model_select_limit: 3;
+        };
+        readonly selection: {
+            readonly mode: 'graph_first_local_build';
+            readonly max_models: 25;
+            readonly max_processes_per_model: 12;
+            readonly decision_factors: readonly ['shared product system or classification lineage', 'explicit exchange connectivity', 'quantitative reference completeness', 'geography and time coherence'];
+        };
+        readonly reuse: {
+            readonly reusable_process_dirs: readonly [];
+            readonly include_reference_model_resulting_processes: true;
+        };
+        readonly output: {
+            readonly write_local_models: true;
+            readonly emit_validation_report: false;
+        };
+        readonly local_runs: readonly [];
+        readonly publish: {
+            readonly enabled: false;
+            readonly mode: 'deferred_to_publish_build';
+            readonly target_runs: readonly [];
+            readonly select_after_insert: true;
+            readonly max_attempts: 5;
+            readonly retry_delay_seconds: 2;
+        };
+    };
+    copyJson: typeof copyJson;
+    ensureList: typeof ensureList;
+    numberOrZero: typeof numberOrZero;
+    firstText: typeof firstText;
+    langTextMap: typeof langTextMap;
+    localizedText: typeof localizedText;
+    multilangText: typeof multilangText;
+    multilangFromText: typeof multilangFromText;
+    deepMerge: typeof deepMerge;
+    buildLayout: typeof buildLayout;
+    buildSelectionBrief: typeof buildSelectionBrief;
+    buildReferenceModelSummary: typeof buildReferenceModelSummary;
+    normalizeLocalRuns: typeof normalizeLocalRuns;
+    uuid5FromText: typeof uuid5FromText;
+    extractClassificationPath: typeof extractClassificationPath;
+    classificationOverlap: typeof classificationOverlap;
+    extractFlowDatasetFromState: typeof extractFlowDatasetFromState;
+    resolvePublicationBlock: typeof resolvePublicationBlock;
+    loadProcessRecord: typeof loadProcessRecord;
+    scoreEdgeCandidate: typeof scoreEdgeCandidate;
+    inferEdges: typeof inferEdges;
+    chooseReferenceProcess: typeof chooseReferenceProcess;
+    collectReachable: typeof collectReachable;
+    topologicalOrder: typeof topologicalOrder;
+    computeMultiplicationFactors: typeof computeMultiplicationFactors;
+    exchangeAmount: typeof exchangeAmount;
+    cloneExchangeWithAmount: typeof cloneExchangeWithAmount;
+    buildProcessInstances: typeof buildProcessInstances;
+    buildLifecycleModelDataset: typeof buildLifecycleModelDataset;
+    buildPlan: typeof buildPlan;
+    formatNumber: typeof formatNumber;
+    buildNameSummary: typeof buildNameSummary;
+    toJsonNumber: typeof toJsonNumber;
+};
+export {};

package/dist/src/lib/lifecyclemodel-bundle-save.d.ts

@@ -0,0 +1,71 @@
+import type { FetchLike } from './http.js';
+type JsonObject = Record<string, unknown>;
+export type LifecyclemodelPublishMetadata = {
+    json_tg?: JsonObject;
+    processMutations?: JsonObject[];
+    ruleVerification?: boolean;
+};
+type LifecyclemodelVisibleRow = {
+    id: string;
+    version: string;
+};
+type LifecyclemodelBundlePlan = {
+    mode: 'create' | 'update';
+    modelId: string;
+    version?: string;
+    parent: {
+        jsonOrdered: JsonObject;
+        jsonTg: JsonObject;
+        ruleVerification?: boolean;
+    };
+    processMutations: JsonObject[];
+};
+export type LifecyclemodelBundleWriteResult = {
+    status: 'success';
+    operation: 'create' | 'update' | 'update_after_create_conflict';
+    mode: 'create' | 'update';
+    transport: 'save_lifecycle_model_bundle';
+    response: JsonObject;
+};
+declare function trimToken(value: unknown): string | null;
+declare function firstNonEmpty(...values: unknown[]): string | null;
+declare function matchingResultingProcessType(instance: JsonObject, payload: JsonObject): 'primary' | 'secondary';
+export declare function deriveLifecyclemodelJsonTg(payload: JsonObject): JsonObject;
+declare function mergeLifecyclemodelJsonTg(explicit: JsonObject | null, derived: JsonObject): JsonObject;
+export declare function buildLifecyclemodelBundlePlan(options: {
+    id: string;
+    version: string;
+    payload: JsonObject;
+    metadata?: LifecyclemodelPublishMetadata | null;
+    mode: 'create' | 'update';
+}): LifecyclemodelBundlePlan;
+declare function parseVisibleRows(payload: unknown, url: string): LifecyclemodelVisibleRow[];
+declare function exactVisibleRows(options: {
+    id: string;
+    version: string;
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+}): Promise<LifecyclemodelVisibleRow[]>;
+declare function requireLifecyclemodelBundleResponse(payload: unknown, url: string): JsonObject;
+export declare function syncLifecyclemodelBundleRecord(options: {
+    id: string;
+    version: string;
+    payload: JsonObject;
+    metadata?: LifecyclemodelPublishMetadata | null;
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+    timeoutMs?: number;
+}): Promise<LifecyclemodelBundleWriteResult>;
+export declare const __testInternals: {
+    buildLifecyclemodelBundlePlan: typeof buildLifecyclemodelBundlePlan;
+    deriveLifecyclemodelJsonTg: typeof deriveLifecyclemodelJsonTg;
+    exactVisibleRows: typeof exactVisibleRows;
+    firstNonEmpty: typeof firstNonEmpty;
+    matchingResultingProcessType: typeof matchingResultingProcessType;
+    mergeLifecyclemodelJsonTg: typeof mergeLifecyclemodelJsonTg;
+    parseVisibleRows: typeof parseVisibleRows;
+    requireLifecyclemodelBundleResponse: typeof requireLifecyclemodelBundleResponse;
+    trimToken: typeof trimToken;
+};
+export {};