@tiangong-lca/cli 0.0.11 → 0.0.13

package/dist/src/lib/dataset-save-draft-run.js

@@ -0,0 +1,725 @@
+import path from 'node:path';
+import * as tidasSdk from '@tiangong-lca/tidas-sdk';
+import { writeJsonArtifact, writeJsonLinesArtifact } from './artifacts.js';
+import { collectImportContentIssues } from './dataset-validate.js';
+import { createDatasetRecord, saveDraftDatasetRecord, } from './dataset-command.js';
+import { readDatasetRowsInput } from './dataset-local.js';
+import { CliError } from './errors.js';
+import { normalizeIssuePath, validateSchemaWithDeepFallback, } from './tidas-sdk-validation.js';
+import { collectProcessPlaceholderIssues, collectProcessRequiredFieldIssues, } from './process-required-fields.js';
+import { buildDatasetCommandTransport } from './dataset-command.js';
+import { createSupabaseDataClient, requireSupabaseRestRuntime, runSupabaseArrayQuery, } from './supabase-client.js';
+import { createSupabaseDataRuntime } from './supabase-session.js';
+import { collectRemoteReferences, lookupRemoteDataset, } from './dataset-remote-verify.js';
+const DEFAULT_TIMEOUT_MS = 10_000;
+function normalizeValidationIssue(issue) {
+    return {
+        path: normalizeIssuePath(issue.path ?? []),
+        message: issue.message ?? 'Validation failed',
+        code: issue.code ?? 'custom',
+    };
+}
+const DATASET_CONFIGS = {
+    contact: {
+        table: 'contacts',
+        rootKey: 'contactDataSet',
+        informationKey: 'contactInformation',
+        schemaName: 'ContactSchema',
+        factoryName: 'createContact',
+    },
+    source: {
+        table: 'sources',
+        rootKey: 'sourceDataSet',
+        informationKey: 'sourceInformation',
+        schemaName: 'SourceSchema',
+        factoryName: 'createSource',
+    },
+    unitgroup: {
+        table: 'unitgroups',
+        rootKey: 'unitGroupDataSet',
+        informationKey: 'unitGroupInformation',
+        schemaName: 'UnitGroupSchema',
+        factoryName: 'createUnitGroup',
+    },
+    flowproperty: {
+        table: 'flowproperties',
+        rootKey: 'flowPropertyDataSet',
+        informationKey: 'flowPropertiesInformation',
+        schemaName: 'FlowPropertySchema',
+        factoryName: 'createFlowProperty',
+    },
+    flow: {
+        table: 'flows',
+        rootKey: 'flowDataSet',
+        informationKey: 'flowInformation',
+        schemaName: 'FlowSchema',
+        factoryName: 'createFlow',
+    },
+    process: {
+        table: 'processes',
+        rootKey: 'processDataSet',
+        informationKey: 'processInformation',
+        schemaName: 'ProcessSchema',
+        factoryName: 'createProcess',
+    },
+};
+const REFERENCE_ONLY_SAVE_DRAFT_TYPES = new Set([
+    'unitgroup',
+    'flowproperty',
+]);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function trimToken(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+function serializeError(error) {
+    if (error instanceof CliError) {
+        return { message: error.message, details: error.details };
+    }
+    if (error instanceof Error) {
+        return { message: error.message };
+    }
+    return { message: String(error) };
+}
+function normalizeType(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized || normalized === 'auto') {
+        return 'auto';
+    }
+    if (normalized === 'contact' || normalized === 'contacts') {
+        return 'contact';
+    }
+    if (normalized === 'source' || normalized === 'sources') {
+        return 'source';
+    }
+    if (normalized === 'unitgroup' ||
+        normalized === 'unitgroups' ||
+        normalized === 'unit-group' ||
+        normalized === 'unit-groups') {
+        throw new CliError('Unit groups are reference-only support data for dataset save-draft. Select an existing database row instead of creating a custom My Data unit group.', {
+            code: 'DATASET_SAVE_DRAFT_REFERENCE_ONLY_TYPE',
+            exitCode: 2,
+            details: { type: normalized },
+        });
+    }
+    if (normalized === 'flowproperty' ||
+        normalized === 'flowproperties' ||
+        normalized === 'flow-property' ||
+        normalized === 'flow-properties') {
+        throw new CliError('Flow properties are reference-only support data for dataset save-draft. Select an existing database row instead of creating a custom My Data flow property.', {
+            code: 'DATASET_SAVE_DRAFT_REFERENCE_ONLY_TYPE',
+            exitCode: 2,
+            details: { type: normalized },
+        });
+    }
+    if (normalized === 'flow' || normalized === 'flows') {
+        return 'flow';
+    }
+    if (normalized === 'process' || normalized === 'processes') {
+        return 'process';
+    }
+    throw new CliError('Expected --type to be auto, contact, source, flow, or process.', {
+        code: 'DATASET_SAVE_DRAFT_TYPE_INVALID',
+        exitCode: 2,
+        details: value,
+    });
+}
+function unwrapPayload(row) {
+    for (const key of ['json_ordered', 'jsonOrdered', 'payload', 'json']) {
+        if (isRecord(row[key])) {
+            return row[key];
+        }
+    }
+    return row;
+}
+function detectType(payload) {
+    for (const [type, config] of Object.entries(DATASET_CONFIGS)) {
+        if (isRecord(payload[config.rootKey])) {
+            return type;
+        }
+    }
+    return null;
+}
+function schemaForConfig(config) {
+    const schema = tidasSdk[config.schemaName];
+    if (!schema ||
+        typeof schema !== 'object' ||
+        typeof schema.safeParse !== 'function') {
+        throw new CliError(`${String(config.schemaName)} is unavailable in @tiangong-lca/tidas-sdk.`, {
+            code: 'DATASET_SAVE_DRAFT_SCHEMA_UNAVAILABLE',
+            exitCode: 2,
+            details: { table: config.table },
+        });
+    }
+    const createEntity = tidasSdk[config.factoryName];
+    return {
+        schema: schema,
+        createEntity: typeof createEntity === 'function' ? createEntity : null,
+    };
+}
+function validatePayload(payload, type, config) {
+    const { schema, createEntity } = schemaForConfig(config);
+    const outcome = validateSchemaWithDeepFallback(schema, payload, createEntity);
+    const processIssues = type === 'process'
+        ? [...collectProcessRequiredFieldIssues(payload), ...collectProcessPlaceholderIssues(payload)]
+        : [];
+    const importIssues = type === 'process' ? [] : collectImportContentIssues(payload);
+    const issues = [
+        ...outcome.issues.map(normalizeValidationIssue),
+        ...processIssues,
+        ...importIssues,
+    ];
+    if (outcome.success && issues.length === 0) {
+        return {
+            ok: true,
+            validator: `@tiangong-lca/tidas-sdk/${String(config.schemaName)}+tiangong/import-content`,
+            issue_count: 0,
+            issues: [],
+        };
+    }
+    return {
+        ok: false,
+        validator: `@tiangong-lca/tidas-sdk/${String(config.schemaName)}+tiangong/import-content`,
+        issue_count: issues.length,
+        issues,
+    };
+}
+function extractIdentity(payload, row, config) {
+    const rootCandidate = payload[config.rootKey];
+    const root = isRecord(rootCandidate) ? rootCandidate : payload;
+    const informationCandidate = root[config.informationKey];
+    const information = isRecord(informationCandidate) ? informationCandidate : {};
+    const dataSetInformationCandidate = information.dataSetInformation;
+    const dataSetInformation = isRecord(dataSetInformationCandidate)
+        ? dataSetInformationCandidate
+        : {};
+    const administrativeInformation = isRecord(root.administrativeInformation)
+        ? root.administrativeInformation
+        : {};
+    const publicationAndOwnership = isRecord(administrativeInformation.publicationAndOwnership)
+        ? administrativeInformation.publicationAndOwnership
+        : {};
+    return {
+        id: trimToken(row.id) ?? trimToken(dataSetInformation['common:UUID']),
+        version: trimToken(row.version) ?? trimToken(publicationAndOwnership['common:dataSetVersion']) ?? null,
+    };
+}
+function flowType(payload) {
+    const rootCandidate = payload.flowDataSet;
+    const root = isRecord(rootCandidate) ? rootCandidate : payload;
+    const modellingCandidate = root.modellingAndValidation;
+    const modelling = isRecord(modellingCandidate) ? modellingCandidate : {};
+    const lciMethodCandidate = modelling.LCIMethod;
+    const lciMethod = isRecord(lciMethodCandidate) ? lciMethodCandidate : {};
+    return trimToken(lciMethod.typeOfDataSet);
+}
+function isElementaryFlowPayload(payload) {
+    return flowType(payload)?.trim().toLowerCase() === 'elementary flow';
+}
+function compareVersions(left, right) {
+    if (!left && !right) {
+        return 0;
+    }
+    if (!left) {
+        return -1;
+    }
+    if (!right) {
+        return 1;
+    }
+    const leftParts = left.split(/[._-]/u);
+    const rightParts = right.split(/[._-]/u);
+    const length = Math.max(leftParts.length, rightParts.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftPart = leftParts[index] ?? '0';
+        const rightPart = rightParts[index] ?? '0';
+        const leftNumber = Number(leftPart);
+        const rightNumber = Number(rightPart);
+        if (Number.isFinite(leftNumber) && Number.isFinite(rightNumber)) {
+            if (leftNumber !== rightNumber) {
+                return leftNumber > rightNumber ? 1 : -1;
+            }
+        }
+        else {
+            const compared = leftPart.localeCompare(rightPart);
+            if (compared !== 0) {
+                return compared > 0 ? 1 : -1;
+            }
+        }
+    }
+    return 0;
+}
+function supportLookupKey(reference) {
+    return `${reference.table}:${reference.id}:${reference.version ?? ''}`;
+}
+function isLookupableRemoteReference(reference) {
+    return Boolean(reference.table && reference.id);
+}
+function uniqueFlowRemoteReferences(payload) {
+    const references = new Map();
+    for (const reference of collectRemoteReferences([payload])) {
+        if (reference.role !== 'reference') {
+            continue;
+        }
+        if (reference.table && reference.id) {
+            references.set(supportLookupKey({
+                table: reference.table,
+                id: reference.id,
+                version: reference.version,
+            }), reference);
+        }
+        else {
+            references.set(remoteReferenceFallbackKey(reference), reference);
+        }
+    }
+    return [...references.values()];
+}
+function remoteReferenceFallbackKey(reference) {
+    return `${reference.path}:${reference.type ?? 'unknown'}`;
+}
+async function lookupCachedReferenceOnlySupport(options) {
+    const key = supportLookupKey(options.reference);
+    if (!options.cache.has(key)) {
+        options.cache.set(key, lookupRemoteDataset({
+            runtime: options.runtime,
+            fetchImpl: options.fetchImpl,
+            timeoutMs: options.timeoutMs,
+            request: {
+                table: options.reference.table,
+                id: options.reference.id,
+                version: options.reference.version,
+            },
+        }));
+    }
+    return options.cache.get(key);
+}
+async function missingFlowRemoteReferences(options) {
+    const missing = [];
+    for (const reference of uniqueFlowRemoteReferences(options.payload)) {
+        if (!isLookupableRemoteReference(reference)) {
+            missing.push({
+                table: reference.table,
+                id: reference.id,
+                version: reference.version,
+                path: reference.path,
+                short_description: reference.short_description,
+                status: 'unsupported_type',
+                latest_version: null,
+            });
+            continue;
+        }
+        if (!reference.version) {
+            missing.push({
+                table: reference.table,
+                id: reference.id,
+                version: null,
+                path: reference.path,
+                short_description: reference.short_description,
+                status: 'version_missing',
+                latest_version: null,
+            });
+            continue;
+        }
+        const lookup = await lookupCachedReferenceOnlySupport({ ...options, reference });
+        if (!lookup.latest) {
+            missing.push({
+                table: reference.table,
+                id: reference.id,
+                version: reference.version,
+                path: reference.path,
+                short_description: reference.short_description,
+                status: 'missing_dataset',
+                latest_version: null,
+            });
+        }
+        else if (!lookup.exact) {
+            missing.push({
+                table: reference.table,
+                id: reference.id,
+                version: reference.version,
+                path: reference.path,
+                short_description: reference.short_description,
+                status: 'missing_version',
+                latest_version: lookup.latest.version,
+            });
+        }
+        else if (compareVersions(lookup.latest.version, reference.version) > 0) {
+            missing.push({
+                table: reference.table,
+                id: reference.id,
+                version: reference.version,
+                path: reference.path,
+                short_description: reference.short_description,
+                status: 'version_outdated',
+                latest_version: lookup.latest.version,
+            });
+        }
+    }
+    return missing;
+}
+function prepareRows(inputPath, rawInput, requestedType) {
+    const rows = readDatasetRowsInput(inputPath, rawInput);
+    return rows.map((row, index) => {
+        const payload = unwrapPayload(row);
+        const type = requestedType === 'auto' ? detectType(payload) : requestedType;
+        const config = type ? DATASET_CONFIGS[type] : null;
+        const identity = config ? extractIdentity(payload, row, config) : { id: null, version: null };
+        return {
+            index,
+            row,
+            payload,
+            type,
+            config,
+            id: identity.id,
+            version: identity.version,
+            validation: config && type ? validatePayload(payload, type, config) : null,
+        };
+    });
+}
+function buildFiles(outDir) {
+    const outputDir = path.join(outDir, 'outputs', 'dataset-save-draft');
+    return {
+        selected_rows: path.join(outputDir, 'selected-rows.jsonl'),
+        progress_jsonl: path.join(outputDir, 'progress.jsonl'),
+        failures_jsonl: path.join(outputDir, 'failures.jsonl'),
+        summary_json: path.join(outputDir, 'summary.json'),
+    };
+}
+function defaultOutDir(inputPath, commit, now) {
+    const mode = commit ? 'commit' : 'dry-run';
+    const timestamp = now.toISOString().replace(/[:.]/gu, '').replace(/Z$/u, 'Z');
+    return path.join(path.dirname(inputPath), 'artifacts', 'dataset-save-draft', `${mode}-${timestamp}`);
+}
+function operationCount(rows) {
+    const counts = {};
+    for (const row of rows) {
+        const key = row.operation ?? 'none';
+        counts[key] = (counts[key] ?? 0) + 1;
+    }
+    return counts;
+}
+function byTable(rows) {
+    const counts = {};
+    for (const row of rows) {
+        if (row.config) {
+            counts[row.config.table] = (counts[row.config.table] ?? 0) + 1;
+        }
+    }
+    return counts;
+}
+function selectedRow(row) {
+    return {
+        index: row.index,
+        type: row.type,
+        table: row.config?.table ?? null,
+        id: row.id,
+        version: row.version,
+        validation: row.validation,
+        payload: row.payload,
+    };
+}
+function buildPreparedFailure(row) {
+    if (!row.type || !row.config) {
+        return {
+            index: row.index,
+            id: row.id,
+            version: row.version,
+            type: row.type,
+            table: null,
+            status: 'failed',
+            operation: 'type_unknown',
+            validation: null,
+            error: {
+                message: 'Could not detect dataset type. Use --type or provide a supported TIDAS wrapper.',
+            },
+        };
+    }
+    if (REFERENCE_ONLY_SAVE_DRAFT_TYPES.has(row.type)) {
+        return {
+            index: row.index,
+            id: row.id,
+            version: row.version,
+            type: row.type,
+            table: row.config.table,
+            status: 'failed',
+            operation: 'reference_only_type',
+            validation: row.validation,
+            error: {
+                message: 'Unit Groups and Flow Properties are reference-only support data. Rewrite references to existing database rows instead of writing these rows through dataset save-draft.',
+            },
+        };
+    }
+    if (!row.id || !row.version) {
+        return {
+            index: row.index,
+            id: row.id,
+            version: row.version,
+            type: row.type,
+            table: row.config.table,
+            status: 'failed',
+            operation: 'identity_missing',
+            validation: row.validation,
+            error: {
+                message: 'Dataset row is missing common:UUID or common:dataSetVersion required for save-draft.',
+            },
+        };
+    }
+    if (!row.validation?.ok) {
+        return {
+            index: row.index,
+            id: row.id,
+            version: row.version,
+            type: row.type,
+            table: row.config.table,
+            status: 'failed',
+            operation: 'skipped_invalid',
+            validation: row.validation,
+            error: {
+                message: `Local dataset validation failed with ${row.validation?.issue_count ?? 0} issue(s).`,
+            },
+        };
+    }
+    return null;
+}
+function buildVisibleRowsUrl(restBaseUrl, table, id, version) {
+    const url = new URL(`${restBaseUrl.replace(/\/+$/u, '')}/${table}`);
+    url.searchParams.set('select', 'id,version,user_id,state_code');
+    url.searchParams.set('id', `eq.${id}`);
+    url.searchParams.set('version', `eq.${version}`);
+    return url.toString();
+}
+function parseVisibleRows(payload, url) {
+    if (!Array.isArray(payload)) {
+        throw new CliError(`Supabase REST response was not a JSON array for ${url}`, {
+            code: 'SUPABASE_REST_RESPONSE_INVALID',
+            exitCode: 1,
+            details: payload,
+        });
+    }
+    return payload.map((item, index) => {
+        if (!isRecord(item)) {
+            throw new CliError(`Supabase REST row ${index} was not a JSON object for ${url}`, {
+                code: 'SUPABASE_REST_RESPONSE_INVALID',
+                exitCode: 1,
+                details: item,
+            });
+        }
+        return {
+            id: trimToken(item.id) ?? '',
+            version: trimToken(item.version) ?? '',
+            user_id: trimToken(item.user_id),
+            state_code: typeof item.state_code === 'number' ? item.state_code : null,
+        };
+    });
+}
+async function exactVisibleRows(options) {
+    const url = buildVisibleRowsUrl(options.restBaseUrl, options.table, options.id, options.version);
+    const payload = await runSupabaseArrayQuery(options.client
+        .from(options.table)
+        .select('id,version,user_id,state_code')
+        .eq('id', options.id)
+        .eq('version', options.version), url);
+    return parseVisibleRows(payload, url);
+}
+export async function runDatasetSaveDraft(options) {
+    const now = options.now ?? new Date();
+    const inputPath = path.resolve(options.inputPath);
+    const commit = options.commit === true;
+    const requestedType = normalizeType(options.type);
+    const outDir = path.resolve(options.outDir ?? defaultOutDir(inputPath, commit, now));
+    const files = buildFiles(outDir);
+    const preparedRows = prepareRows(inputPath, options.rawInput, requestedType);
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (commit && (!options.env || !options.fetchImpl)) {
+        throw new CliError('Dataset save-draft commit requires env and fetch runtime bindings.', {
+            code: 'DATASET_SAVE_DRAFT_RUNTIME_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    writeJsonLinesArtifact(files.selected_rows, preparedRows.map(selectedRow));
+    const runtime = commit && options.env && options.fetchImpl
+        ? createSupabaseDataRuntime({
+            runtime: requireSupabaseRestRuntime(options.env),
+            fetchImpl: options.fetchImpl,
+            timeoutMs,
+        })
+        : null;
+    const commandTransport = runtime && options.fetchImpl
+        ? await buildDatasetCommandTransport({
+            runtime,
+            fetchImpl: options.fetchImpl,
+            timeoutMs,
+        })
+        : null;
+    const dataClient = runtime && options.fetchImpl
+        ? createSupabaseDataClient(runtime, options.fetchImpl, timeoutMs)
+        : null;
+    const referenceOnlySupportCache = new Map();
+    const reports = [];
+    for (const row of preparedRows) {
+        const preparedFailure = buildPreparedFailure(row);
+        if (preparedFailure) {
+            reports.push(preparedFailure);
+            continue;
+        }
+        const baseReport = {
+            index: row.index,
+            id: row.id,
+            version: row.version,
+            type: row.type,
+            table: row.config.table,
+            status: 'prepared',
+            operation: 'would_sync',
+            validation: row.validation,
+        };
+        if (!commit) {
+            reports.push(baseReport);
+            continue;
+        }
+        try {
+            const visibleRows = await exactVisibleRows({
+                client: dataClient.client,
+                restBaseUrl: dataClient.restBaseUrl,
+                table: row.config.table,
+                id: row.id,
+                version: row.version,
+            });
+            const visibleRow = visibleRows[0] ?? null;
+            if (row.type === 'flow') {
+                if (!visibleRow && isElementaryFlowPayload(row.payload)) {
+                    reports.push({
+                        ...baseReport,
+                        status: 'failed',
+                        operation: 'elementary_flow_insert_blocked',
+                        visible_row: null,
+                        error: {
+                            message: 'Elementary flows are reference-only for dataset save-draft. Resolve the flow with remote hybrid search and reference the existing database row instead of creating a My Data flow.',
+                            details: {
+                                code: 'DATASET_SAVE_DRAFT_ELEMENTARY_FLOW_INSERT_BLOCKED',
+                            },
+                        },
+                    });
+                    continue;
+                }
+                const unresolvedReferences = await missingFlowRemoteReferences({
+                    runtime: runtime,
+                    fetchImpl: options.fetchImpl,
+                    timeoutMs,
+                    cache: referenceOnlySupportCache,
+                    payload: row.payload,
+                });
+                if (unresolvedReferences.length > 0) {
+                    reports.push({
+                        ...baseReport,
+                        status: 'failed',
+                        operation: 'remote_reference_unresolved',
+                        visible_row: visibleRow,
+                        error: {
+                            message: 'Flow save-draft commit requires all referenced datasets to already resolve in the remote database.',
+                            details: {
+                                code: 'DATASET_SAVE_DRAFT_REMOTE_REFERENCE_UNRESOLVED',
+                                references: unresolvedReferences,
+                            },
+                        },
+                    });
+                    continue;
+                }
+            }
+            if (visibleRow) {
+                await saveDraftDatasetRecord({
+                    transport: commandTransport,
+                    table: row.config.table,
+                    id: row.id,
+                    version: row.version,
+                    payload: row.payload,
+                    extraData: { ruleVerification: true },
+                });
+                reports.push({
+                    ...baseReport,
+                    status: 'executed',
+                    operation: 'save_draft',
+                    visible_row: visibleRow,
+                });
+            }
+            else {
+                await createDatasetRecord({
+                    transport: commandTransport,
+                    table: row.config.table,
+                    id: row.id,
+                    payload: row.payload,
+                    extraData: { ruleVerification: true },
+                });
+                reports.push({
+                    ...baseReport,
+                    status: 'executed',
+                    operation: 'insert',
+                    visible_row: null,
+                });
+            }
+        }
+        catch (error) {
+            reports.push({
+                ...baseReport,
+                status: 'failed',
+                error: serializeError(error),
+            });
+        }
+    }
+    const failures = reports.filter((row) => row.status === 'failed');
+    writeJsonLinesArtifact(files.progress_jsonl, reports);
+    writeJsonLinesArtifact(files.failures_jsonl, failures);
+    const report = {
+        schema_version: 1,
+        generated_at_utc: now.toISOString(),
+        input_path: inputPath,
+        requested_type: requestedType,
+        out_dir: outDir,
+        commit,
+        mode: commit ? 'commit' : 'dry_run',
+        status: failures.length > 0 ? 'completed_with_failures' : 'completed',
+        counts: {
+            selected: preparedRows.length,
+            prepared: reports.filter((row) => row.status === 'prepared').length,
+            executed: reports.filter((row) => row.status === 'executed').length,
+            failed: failures.length,
+            by_table: byTable(preparedRows),
+            operations: operationCount(reports),
+        },
+        files,
+        rows: reports,
+    };
+    writeJsonArtifact(files.summary_json, report);
+    return report;
+}
+export const __testInternals = {
+    DATASET_CONFIGS,
+    buildFiles,
+    buildPreparedFailure,
+    buildVisibleRowsUrl,
+    byTable,
+    compareVersions,
+    defaultOutDir,
+    detectType,
+    extractIdentity,
+    flowType,
+    isElementaryFlowPayload,
+    isLookupableRemoteReference,
+    missingFlowRemoteReferences,
+    normalizeValidationIssue,
+    normalizeType,
+    operationCount,
+    parseVisibleRows,
+    prepareRows,
+    remoteReferenceFallbackKey,
+    selectedRow,
+    serializeError,
+    supportLookupKey,
+    unwrapPayload,
+    uniqueFlowRemoteReferences,
+    validatePayload,
+};
+//# sourceMappingURL=dataset-save-draft-run.js.map