@solana-mobile/dapp-store-cli 0.16.0 → 0.16.1

package/lib/publication/PublicationProgressReporter.js

@@ -0,0 +1,1051 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import * as readline from 'node:readline';
+var SPINNER_FRAMES = [
+    '|',
+    '/',
+    '-',
+    '\\'
+];
+var PHASES = [
+    {
+        key: 'source',
+        label: 'Prepare source'
+    },
+    {
+        key: 'ingestion',
+        label: 'Process APK'
+    },
+    {
+        key: 'context',
+        label: 'Load release context'
+    },
+    {
+        key: 'mint',
+        label: 'Mint release NFT'
+    },
+    {
+        key: 'verify',
+        label: 'Verify collection'
+    },
+    {
+        key: 'attest',
+        label: 'Create attestation'
+    },
+    {
+        key: 'submit',
+        label: 'Submit to review'
+    }
+];
+var PHASE_WEIGHT_PROFILES = {
+    'apk-file': {
+        source: 0.42,
+        ingestion: 0.2,
+        context: 0.08,
+        mint: 0.12,
+        verify: 0.08,
+        attest: 0.04,
+        submit: 0.06
+    },
+    'apk-url': {
+        source: 0.05,
+        ingestion: 0.43,
+        context: 0.12,
+        mint: 0.16,
+        verify: 0.1,
+        attest: 0.05,
+        submit: 0.09
+    },
+    resume: {
+        source: 0.42,
+        ingestion: 0.2,
+        context: 0.08,
+        mint: 0.12,
+        verify: 0.08,
+        attest: 0.04,
+        submit: 0.06
+    }
+};
+var STEP_PROGRESS_RANGES = {
+    'source.prepare': {
+        start: 0.02,
+        end: 0.1
+    },
+    'source.upload': {
+        start: 0.1,
+        end: 1
+    },
+    'source.ready': {
+        start: 0.2,
+        end: 1
+    },
+    'ingestion.create': {
+        start: 0.05,
+        end: 0.2
+    },
+    'ingestion.wait': {
+        start: 0.2,
+        end: 1
+    },
+    'bundle.load': {
+        start: 0.1,
+        end: 0.55
+    },
+    'session.load': {
+        start: 0.55,
+        end: 1
+    },
+    'mint.prepare': {
+        start: 0.05,
+        end: 0.3
+    },
+    'mint.submit': {
+        start: 0.3,
+        end: 0.65
+    },
+    'mint.save': {
+        start: 0.65,
+        end: 1
+    },
+    'verify.prepare': {
+        start: 0.05,
+        end: 0.35
+    },
+    'verify.submit': {
+        start: 0.35,
+        end: 1
+    },
+    'attestation.create': {
+        start: 0.05,
+        end: 1
+    },
+    'submit.store': {
+        start: 0.05,
+        end: 1
+    }
+};
+var DEFAULT_RUNNING_STEP_PROGRESS = 0.2;
+var STEP_TO_PHASE = {
+    'source.prepare': 'source',
+    'source.upload': 'source',
+    'source.ready': 'source',
+    'ingestion.create': 'ingestion',
+    'ingestion.wait': 'ingestion',
+    'bundle.load': 'context',
+    'session.load': 'context',
+    'mint.prepare': 'mint',
+    'mint.submit': 'mint',
+    'mint.save': 'mint',
+    'verify.prepare': 'verify',
+    'verify.submit': 'verify',
+    'attestation.create': 'attest',
+    'submit.store': 'submit'
+};
+var PHASE_FINAL_STEPS = {
+    source: [
+        'source.ready',
+        'source.upload'
+    ],
+    ingestion: [
+        'ingestion.wait'
+    ],
+    context: [
+        'session.load'
+    ],
+    mint: [
+        'mint.save'
+    ],
+    verify: [
+        'verify.submit'
+    ],
+    attest: [
+        'attestation.create'
+    ],
+    submit: [
+        'submit.store'
+    ]
+};
+var STAGE_COMPLETED_PHASES = {
+    PreparedForMint: [
+        'source',
+        'ingestion',
+        'context'
+    ],
+    MintSubmitted: [
+        'source',
+        'ingestion',
+        'context'
+    ],
+    MintSaved: [
+        'source',
+        'ingestion',
+        'context',
+        'mint'
+    ],
+    VerificationSubmitted: [
+        'source',
+        'ingestion',
+        'context',
+        'mint'
+    ],
+    Verified: [
+        'source',
+        'ingestion',
+        'context',
+        'mint',
+        'verify'
+    ],
+    Attested: [
+        'source',
+        'ingestion',
+        'context',
+        'mint',
+        'verify',
+        'attest'
+    ],
+    Submitted: [
+        'source',
+        'ingestion',
+        'context',
+        'mint',
+        'verify',
+        'attest',
+        'submit'
+    ]
+};
+var MAX_RECENT_EVENTS = 2;
+var VERBOSE_PREFIX = 'Verbose';
+export function createPublicationProgressReporter(input) {
+    return new PublicationProgressReporter(input);
+}
+var PublicationProgressReporter = /*#__PURE__*/ function() {
+    "use strict";
+    function PublicationProgressReporter(input) {
+        var _this = this;
+        _class_call_check(this, PublicationProgressReporter);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "title", void 0);
+        _define_property(this, "stream", void 0);
+        _define_property(this, "interactive", void 0);
+        _define_property(this, "verbose", void 0);
+        _define_property(this, "phaseStates", void 0);
+        _define_property(this, "phaseProgress", void 0);
+        _define_property(this, "verboseValues", new Map());
+        _define_property(this, "currentMessage", void 0);
+        _define_property(this, "recentEvents", []);
+        _define_property(this, "context", {});
+        _define_property(this, "spinnerIndex", 0);
+        _define_property(this, "renderedLineCount", 0);
+        _define_property(this, "intervalId", void 0);
+        _define_property(this, "finalState", void 0);
+        this.title = input.title;
+        var _input_stream;
+        this.stream = (_input_stream = input.stream) !== null && _input_stream !== void 0 ? _input_stream : process.stdout;
+        this.interactive = Boolean(this.stream.isTTY) && process.env.TERM !== 'dumb';
+        this.verbose = Boolean(input.verbose);
+        this.phaseStates = Object.fromEntries(PHASES.map(function(param) {
+            var key = param.key;
+            return [
+                key,
+                'pending'
+            ];
+        }));
+        this.phaseProgress = Object.fromEntries(PHASES.map(function(param) {
+            var key = param.key;
+            return [
+                key,
+                0
+            ];
+        }));
+        this.currentMessage = input.mode === 'resume' ? 'Loading existing publication state' : 'Preparing publication workflow';
+        if (input.mode === 'resume') {
+            this.context.sourceKind = 'resume';
+        }
+        if (input.mode === 'resume') {
+            this.phaseStates.source = 'complete';
+            this.phaseStates.ingestion = 'complete';
+            this.phaseProgress.source = 1;
+            this.phaseProgress.ingestion = 1;
+        }
+        this.logger = {
+            debug: function(message, metadata) {
+                _this.handleEvent('debug', message, metadata);
+            },
+            info: function(message, metadata) {
+                _this.handleEvent('info', message, metadata);
+            },
+            warn: function(message, metadata) {
+                _this.handleEvent('warn', message, metadata);
+            }
+        };
+    }
+    _create_class(PublicationProgressReporter, [
+        {
+            key: "start",
+            value: function start(input) {
+                var _this = this;
+                if (input === null || input === void 0 ? void 0 : input.message) {
+                    this.currentMessage = input.message;
+                }
+                if (input === null || input === void 0 ? void 0 : input.metadata) {
+                    this.updateContext(input.metadata);
+                }
+                this.ensureActivePhase();
+                if (this.interactive) {
+                    var _this_intervalId_unref, _this_intervalId;
+                    this.stream.write('\x1B[?25l');
+                    this.render();
+                    this.intervalId = setInterval(function() {
+                        if (_this.finalState) {
+                            return;
+                        }
+                        _this.spinnerIndex = (_this.spinnerIndex + 1) % SPINNER_FRAMES.length;
+                        _this.render();
+                    }, 120);
+                    (_this_intervalId_unref = (_this_intervalId = this.intervalId).unref) === null || _this_intervalId_unref === void 0 ? void 0 : _this_intervalId_unref.call(_this_intervalId);
+                    return;
+                }
+                console.log("".concat(this.title, ": ").concat(this.currentMessage));
+            }
+        },
+        {
+            key: "complete",
+            value: function complete(result) {
+                this.finalState = 'complete';
+                this.currentMessage = 'Publication workflow completed';
+                var _result_collectionTransactionSignature;
+                this.updateContext({
+                    androidPackage: result.publicationBundle.release.androidPackage,
+                    versionName: result.publicationBundle.release.versionName,
+                    releaseId: result.releaseId,
+                    publicationSessionId: result.publicationSessionId,
+                    ingestionSessionId: result.ingestionSessionId,
+                    mintAddress: result.releaseMintAddress,
+                    transactionSignature: (_result_collectionTransactionSignature = result.collectionTransactionSignature) !== null && _result_collectionTransactionSignature !== void 0 ? _result_collectionTransactionSignature : result.releaseTransactionSignature,
+                    hubspotTicketId: result.hubspotTicketId,
+                    requestUniqueId: result.attestationRequestUniqueId
+                });
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = PHASES[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var key = _step.value.key;
+                        this.phaseStates[key] = 'complete';
+                        this.phaseProgress[key] = 1;
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                this.pushRecentEvent('Publication workflow completed');
+                this.stopAndRenderFinalState();
+            }
+        },
+        {
+            key: "fail",
+            value: function fail(error) {
+                this.finalState = 'failed';
+                if (_instanceof(error, Error) && error.message.trim().length > 0) {
+                    this.pushRecentEvent("Failed: ".concat(error.message.trim()));
+                }
+                this.stopAndRenderFinalState();
+            }
+        },
+        {
+            key: "handleEvent",
+            value: function handleEvent(level, message, metadata) {
+                this.currentMessage = message.trim().length > 0 ? message : this.currentMessage;
+                if (metadata) {
+                    this.updateContext(metadata);
+                    this.updatePhaseState(metadata);
+                    this.applyStageHint(metadata);
+                    this.emitVerboseMetadata(metadata);
+                }
+                if (level === 'warn') {
+                    this.pushRecentEvent("Warning: ".concat(message));
+                } else if (level === 'info' && this.readString(metadata, 'status') === 'complete') {
+                    this.pushRecentEvent(message);
+                }
+                if (this.interactive) {
+                    this.render();
+                    return;
+                }
+                if (level === 'debug') {
+                    return;
+                }
+                console.log(this.buildLogLine(level, message, metadata));
+            }
+        },
+        {
+            key: "updatePhaseState",
+            value: function updatePhaseState(metadata) {
+                var step = this.readString(metadata, 'step');
+                if (!step) {
+                    return;
+                }
+                var phaseKey = STEP_TO_PHASE[step];
+                if (!phaseKey) {
+                    return;
+                }
+                var phaseIndex = this.getPhaseIndex(phaseKey);
+                for(var index = 0; index < phaseIndex; index += 1){
+                    this.phaseStates[PHASES[index].key] = 'complete';
+                    this.phaseProgress[PHASES[index].key] = 1;
+                }
+                if (this.phaseStates[phaseKey] !== 'complete') {
+                    this.phaseStates[phaseKey] = 'active';
+                }
+                var status = this.readString(metadata, 'status');
+                var resolvedProgress = this.resolvePhaseProgress(step, metadata, status);
+                if (resolvedProgress !== undefined) {
+                    this.phaseProgress[phaseKey] = Math.max(this.phaseProgress[phaseKey], resolvedProgress);
+                }
+                if (status === 'complete' && PHASE_FINAL_STEPS[phaseKey].includes(step)) {
+                    this.phaseStates[phaseKey] = 'complete';
+                    this.phaseProgress[phaseKey] = 1;
+                    this.ensureActivePhase();
+                }
+            }
+        },
+        {
+            key: "resolvePhaseProgress",
+            value: function resolvePhaseProgress(step, metadata, status) {
+                var range = STEP_PROGRESS_RANGES[step];
+                var _this_readProgress;
+                var explicitProgress = (_this_readProgress = this.readProgress(metadata, 'stepProgress')) !== null && _this_readProgress !== void 0 ? _this_readProgress : this.readByteProgress(metadata);
+                if (status === 'complete') {
+                    var _range_end;
+                    return (_range_end = range === null || range === void 0 ? void 0 : range.end) !== null && _range_end !== void 0 ? _range_end : 1;
+                }
+                if (!range) {
+                    return explicitProgress;
+                }
+                if (explicitProgress !== undefined) {
+                    return this.interpolateProgress(range, explicitProgress);
+                }
+                if (status === 'running') {
+                    return this.interpolateProgress(range, DEFAULT_RUNNING_STEP_PROGRESS);
+                }
+                return undefined;
+            }
+        },
+        {
+            key: "interpolateProgress",
+            value: function interpolateProgress(range, progress) {
+                var clampedProgress = Math.max(0, Math.min(1, progress));
+                return range.start + (range.end - range.start) * clampedProgress;
+            }
+        },
+        {
+            key: "applyStageHint",
+            value: function applyStageHint(metadata) {
+                var stage = this.readString(metadata, 'stage');
+                if (!stage) {
+                    return;
+                }
+                var completedPhases = STAGE_COMPLETED_PHASES[stage];
+                if (!completedPhases) {
+                    return;
+                }
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = completedPhases[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var phaseKey = _step.value;
+                        this.phaseStates[phaseKey] = 'complete';
+                        this.phaseProgress[phaseKey] = 1;
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                this.ensureActivePhase();
+            }
+        },
+        {
+            key: "updateContext",
+            value: function updateContext(metadata) {
+                var sourceKind = this.readString(metadata, 'sourceKind');
+                if (sourceKind === 'apk-file' || sourceKind === 'apk-url' || sourceKind === 'resume') {
+                    this.context.sourceKind = sourceKind;
+                }
+                var fileName = this.readString(metadata, 'fileName');
+                if (fileName) {
+                    this.context.fileName = fileName;
+                }
+                var apkUrl = this.readString(metadata, 'apkUrl');
+                if (apkUrl) {
+                    this.context.apkUrl = apkUrl;
+                }
+                var sourceReleaseId = this.readString(metadata, 'sourceReleaseId');
+                if (sourceReleaseId) {
+                    this.context.sourceReleaseId = sourceReleaseId;
+                }
+                var androidPackage = this.readString(metadata, 'androidPackage');
+                if (androidPackage) {
+                    this.context.androidPackage = androidPackage;
+                }
+                var versionName = this.readString(metadata, 'versionName');
+                if (versionName) {
+                    this.context.versionName = versionName;
+                }
+                var releaseId = this.readString(metadata, 'releaseId');
+                if (releaseId) {
+                    this.context.releaseId = releaseId;
+                }
+                var _this_readString;
+                var publicationSessionId = (_this_readString = this.readString(metadata, 'publicationSessionId')) !== null && _this_readString !== void 0 ? _this_readString : this.readString(metadata, 'sessionId');
+                if (publicationSessionId) {
+                    this.context.publicationSessionId = publicationSessionId;
+                }
+                var ingestionSessionId = this.readString(metadata, 'ingestionSessionId');
+                if (ingestionSessionId) {
+                    this.context.ingestionSessionId = ingestionSessionId;
+                }
+                var mintAddress = this.readString(metadata, 'mintAddress');
+                if (mintAddress) {
+                    this.context.mintAddress = mintAddress;
+                }
+                var transactionSignature = this.readString(metadata, 'transactionSignature');
+                if (transactionSignature) {
+                    this.context.transactionSignature = transactionSignature;
+                }
+                var hubspotTicketId = this.readString(metadata, 'hubspotTicketId');
+                if (hubspotTicketId) {
+                    this.context.hubspotTicketId = hubspotTicketId;
+                }
+                var requestUniqueId = this.readString(metadata, 'requestUniqueId');
+                if (requestUniqueId) {
+                    this.context.requestUniqueId = requestUniqueId;
+                }
+                var fileSize = this.readNumber(metadata, 'fileSize');
+                if (fileSize !== undefined) {
+                    this.context.fileSize = fileSize;
+                }
+                var bytesUploaded = this.readNumber(metadata, 'bytesUploaded');
+                if (bytesUploaded !== undefined) {
+                    this.context.bytesUploaded = bytesUploaded;
+                }
+                var _this_readNumber;
+                var bytesTotal = (_this_readNumber = this.readNumber(metadata, 'bytesTotal')) !== null && _this_readNumber !== void 0 ? _this_readNumber : this.readNumber(metadata, 'fileSize');
+                if (bytesTotal !== undefined) {
+                    this.context.bytesTotal = bytesTotal;
+                }
+                var ingestionStatus = this.readString(metadata, 'ingestionStatus');
+                if (ingestionStatus) {
+                    this.context.ingestionStatus = ingestionStatus;
+                }
+                var ingestionProgress = this.readNumber(metadata, 'ingestionProgress');
+                if (ingestionProgress !== undefined) {
+                    this.context.ingestionProgress = Math.max(0, Math.min(100, ingestionProgress));
+                }
+                var ingestionStage = this.readString(metadata, 'ingestionStage');
+                if (ingestionStage) {
+                    this.context.ingestionStage = ingestionStage;
+                }
+                var ingestionDetail = this.readString(metadata, 'ingestionDetail');
+                if (ingestionDetail) {
+                    this.context.ingestionDetail = ingestionDetail;
+                }
+                var activeStep = this.readString(metadata, 'step');
+                if (activeStep) {
+                    this.context.activeStep = activeStep;
+                }
+            }
+        },
+        {
+            key: "stopAndRenderFinalState",
+            value: function stopAndRenderFinalState() {
+                if (this.intervalId) {
+                    clearInterval(this.intervalId);
+                    this.intervalId = undefined;
+                }
+                if (this.interactive) {
+                    this.render();
+                    this.stream.write('\n');
+                    this.stream.write('\x1B[?25h');
+                    return;
+                }
+                var statusLabel = this.finalState === 'complete' ? 'completed' : 'failed';
+                console.log("".concat(this.title, ": ").concat(statusLabel));
+            }
+        },
+        {
+            key: "ensureActivePhase",
+            value: function ensureActivePhase() {
+                var _this = this;
+                if (this.finalState) {
+                    return;
+                }
+                var activePhase = PHASES.find(function(param) {
+                    var key = param.key;
+                    return _this.phaseStates[key] === 'active';
+                });
+                if (activePhase) {
+                    return;
+                }
+                var nextPendingPhase = PHASES.find(function(param) {
+                    var key = param.key;
+                    return _this.phaseStates[key] === 'pending';
+                });
+                if (nextPendingPhase) {
+                    this.phaseStates[nextPendingPhase.key] = 'active';
+                }
+            }
+        },
+        {
+            key: "render",
+            value: function render() {
+                var lines = this.buildLines();
+                if (this.renderedLineCount > 0) {
+                    readline.moveCursor(this.stream, 0, -(this.renderedLineCount - 1));
+                    readline.cursorTo(this.stream, 0);
+                    readline.clearScreenDown(this.stream);
+                }
+                this.stream.write(lines.join('\n'));
+                this.renderedLineCount = lines.length;
+            }
+        },
+        {
+            key: "buildLines",
+            value: function buildLines() {
+                var _this = this;
+                var completedCount = PHASES.filter(function(param) {
+                    var key = param.key;
+                    return _this.phaseStates[key] === 'complete';
+                }).length;
+                var activePhase = this.getActivePhaseKey();
+                var phaseLabel = activePhase && this.finalState !== 'complete' ? PHASES[this.getPhaseIndex(activePhase)].label : 'Complete';
+                var percent = this.getProgressPercent();
+                var bar = this.buildProgressBar(percent);
+                var statusToken = this.getStatusToken();
+                var lines = [
+                    this.fitToWidth("".concat(this.title, "  [").concat(statusToken, "] ").concat(completedCount, "/").concat(PHASES.length, " complete | ").concat(phaseLabel)),
+                    this.fitToWidth("".concat(bar, " ").concat(Math.round(percent * 100), "%")),
+                    this.fitToWidth("Working: ".concat(this.currentMessage))
+                ].concat(_to_consumable_array(this.buildDetailLines()));
+                return lines;
+            }
+        },
+        {
+            key: "buildDetailLines",
+            value: function buildDetailLines() {
+                var targetTokens = [
+                    this.context.androidPackage ? "app ".concat(this.truncateMiddle(this.context.androidPackage, 42)) : null,
+                    this.context.versionName ? "version ".concat(this.truncateMiddle(this.context.versionName, 24)) : null,
+                    this.context.fileName ? "file ".concat(this.truncateMiddle(this.context.fileName, 26)) : null,
+                    this.context.apkUrl ? "url ".concat(this.truncateMiddle(this.compactUrl(this.context.apkUrl), 32)) : null,
+                    this.context.sourceReleaseId ? "source ".concat(this.compactIdentifier(this.context.sourceReleaseId)) : null
+                ].filter(function(token) {
+                    return token !== null;
+                });
+                var lines = [];
+                if (targetTokens.length > 0) {
+                    lines.push(this.fitToWidth("Target: ".concat(targetTokens.join(' | '))));
+                }
+                var uploadLine = this.buildUploadLine();
+                if (uploadLine) {
+                    lines.push(this.fitToWidth(uploadLine));
+                }
+                var ingestionLine = this.buildIngestionLine();
+                if (ingestionLine) {
+                    lines.push(this.fitToWidth(ingestionLine));
+                }
+                if (this.recentEvents.length > 0) {
+                    lines.push(this.fitToWidth("Recent: ".concat(this.recentEvents[this.recentEvents.length - 1])));
+                }
+                return lines;
+            }
+        },
+        {
+            key: "buildProgressBar",
+            value: function buildProgressBar(percent) {
+                var _this_stream_columns;
+                var columns = (_this_stream_columns = this.stream.columns) !== null && _this_stream_columns !== void 0 ? _this_stream_columns : 100;
+                var barWidth = Math.min(32, Math.max(10, columns - 44));
+                var filled = Math.max(0, Math.min(barWidth, Math.round(percent * barWidth)));
+                var empty = Math.max(0, barWidth - filled);
+                return "[".concat('#'.repeat(filled)).concat('-'.repeat(empty), "]");
+            }
+        },
+        {
+            key: "buildUploadLine",
+            value: function buildUploadLine() {
+                if (this.context.bytesTotal === undefined || this.context.bytesUploaded === undefined) {
+                    return null;
+                }
+                var activeStep = this.context.activeStep;
+                if (activeStep !== 'source.upload' && this.finalState !== 'complete') {
+                    return null;
+                }
+                var ratio = this.context.bytesTotal > 0 ? this.context.bytesUploaded / this.context.bytesTotal : 1;
+                return "Upload: ".concat(this.formatBytes(this.context.bytesUploaded), " / ").concat(this.formatBytes(this.context.bytesTotal), " (").concat(Math.round(Math.max(0, Math.min(1, ratio)) * 100), "%)");
+            }
+        },
+        {
+            key: "buildIngestionLine",
+            value: function buildIngestionLine() {
+                if (!this.context.ingestionStatus && !this.context.ingestionStage && this.context.ingestionProgress === undefined) {
+                    return null;
+                }
+                var activePhase = this.getActivePhaseKey();
+                if (activePhase !== 'ingestion' && this.finalState !== 'complete') {
+                    return null;
+                }
+                var _this_context_ingestionDetail, _ref;
+                var detail = (_ref = (_this_context_ingestionDetail = this.context.ingestionDetail) !== null && _this_context_ingestionDetail !== void 0 ? _this_context_ingestionDetail : this.context.ingestionStage) !== null && _ref !== void 0 ? _ref : this.context.ingestionStatus;
+                var progress = this.context.ingestionProgress === undefined ? null : "".concat(Math.round(this.context.ingestionProgress), "%");
+                if (detail && progress) {
+                    return "Ingestion: ".concat(detail, " (").concat(progress, ")");
+                }
+                if (detail) {
+                    return "Ingestion: ".concat(detail);
+                }
+                if (progress) {
+                    return "Ingestion: ".concat(progress);
+                }
+                return null;
+            }
+        },
+        {
+            key: "getProgressPercent",
+            value: function getProgressPercent() {
+                var _this = this;
+                if (this.finalState === 'complete') {
+                    return 1;
+                }
+                var weights = this.getPhaseWeights();
+                var progress = PHASES.reduce(function(total, param) {
+                    var key = param.key;
+                    var phaseProgress = Math.max(0, Math.min(1, _this.phaseProgress[key]));
+                    return total + phaseProgress * weights[key];
+                }, 0);
+                return Math.max(0, Math.min(0.99, progress));
+            }
+        },
+        {
+            key: "getStatusToken",
+            value: function getStatusToken() {
+                if (this.finalState === 'complete') {
+                    return 'done';
+                }
+                if (this.finalState === 'failed') {
+                    return 'fail';
+                }
+                return SPINNER_FRAMES[this.spinnerIndex];
+            }
+        },
+        {
+            key: "getActivePhaseKey",
+            value: function getActivePhaseKey() {
+                var _this = this;
+                var activePhase = PHASES.find(function(param) {
+                    var key = param.key;
+                    return _this.phaseStates[key] === 'active';
+                });
+                if (activePhase) {
+                    return activePhase.key;
+                }
+                var pendingPhase = PHASES.find(function(param) {
+                    var key = param.key;
+                    return _this.phaseStates[key] === 'pending';
+                });
+                return pendingPhase === null || pendingPhase === void 0 ? void 0 : pendingPhase.key;
+            }
+        },
+        {
+            key: "getPhaseIndex",
+            value: function getPhaseIndex(phaseKey) {
+                return PHASES.findIndex(function(param) {
+                    var key = param.key;
+                    return key === phaseKey;
+                });
+            }
+        },
+        {
+            key: "emitVerboseMetadata",
+            value: function emitVerboseMetadata(metadata) {
+                if (!this.verbose) {
+                    return;
+                }
+                var lines = this.buildVerboseMetadataLines(metadata);
+                if (lines.length === 0) {
+                    return;
+                }
+                if (this.interactive && this.renderedLineCount > 0) {
+                    readline.moveCursor(this.stream, 0, -(this.renderedLineCount - 1));
+                    readline.cursorTo(this.stream, 0);
+                    readline.clearScreenDown(this.stream);
+                    this.renderedLineCount = 0;
+                }
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = lines[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var line = _step.value;
+                        this.stream.write("".concat(line, "\n"));
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "buildVerboseMetadataLines",
+            value: function buildVerboseMetadataLines(metadata) {
+                var lines = [];
+                var step = this.readString(metadata, 'step');
+                this.appendVerboseField(lines, 'releaseId', 'Release ID', this.readString(metadata, 'releaseId'));
+                var _this_readString;
+                this.appendVerboseField(lines, 'publicationSessionId', 'Publication session ID', (_this_readString = this.readString(metadata, 'publicationSessionId')) !== null && _this_readString !== void 0 ? _this_readString : this.readString(metadata, 'sessionId'));
+                this.appendVerboseField(lines, 'ingestionSessionId', 'Ingestion session ID', this.readString(metadata, 'ingestionSessionId'));
+                var transactionSignature = this.readString(metadata, 'transactionSignature');
+                if (transactionSignature) {
+                    var transactionKey = step === 'verify.submit' ? 'collectionTransactionSignature' : 'releaseTransactionSignature';
+                    var transactionLabel = step === 'verify.submit' ? 'Collection transaction signature' : 'Release transaction signature';
+                    this.appendVerboseField(lines, transactionKey, transactionLabel, transactionSignature);
+                }
+                this.appendVerboseField(lines, 'attestationRequestUniqueId', 'Attestation request ID', this.readString(metadata, 'requestUniqueId'));
+                this.appendVerboseField(lines, 'ticketId', 'Ticket ID', this.readString(metadata, 'hubspotTicketId'));
+                return lines;
+            }
+        },
+        {
+            key: "appendVerboseField",
+            value: function appendVerboseField(lines, key, label, value) {
+                if (!value) {
+                    return;
+                }
+                var previousValue = this.verboseValues.get(key);
+                if (previousValue === value) {
+                    return;
+                }
+                this.verboseValues.set(key, value);
+                lines.push("".concat(VERBOSE_PREFIX, ": ").concat(label, ": ").concat(value));
+            }
+        },
+        {
+            key: "pushRecentEvent",
+            value: function pushRecentEvent(message) {
+                this.recentEvents.push(this.truncateMiddle(message.trim(), 96));
+                if (this.recentEvents.length > MAX_RECENT_EVENTS) {
+                    this.recentEvents = this.recentEvents.slice(-MAX_RECENT_EVENTS);
+                }
+            }
+        },
+        {
+            key: "buildLogLine",
+            value: function buildLogLine(level, message, metadata) {
+                var step = this.readString(metadata, 'step');
+                var phaseKey = step ? STEP_TO_PHASE[step] : this.getActivePhaseKey();
+                var phaseIndex = phaseKey ? this.getPhaseIndex(phaseKey) + 1 : 0;
+                var phaseLabel = phaseKey ? PHASES[this.getPhaseIndex(phaseKey)].label : 'Publication workflow';
+                var prefix = level === 'warn' ? 'warning' : phaseIndex > 0 ? "".concat(phaseIndex, "/").concat(PHASES.length) : 'info';
+                return "".concat(prefix, " ").concat(phaseLabel, ": ").concat(message);
+            }
+        },
+        {
+            key: "compactIdentifier",
+            value: function compactIdentifier(value) {
+                return this.truncateMiddle(value, 18);
+            }
+        },
+        {
+            key: "getPhaseWeights",
+            value: function getPhaseWeights() {
+                var _this_context_sourceKind;
+                var profile = (_this_context_sourceKind = this.context.sourceKind) !== null && _this_context_sourceKind !== void 0 ? _this_context_sourceKind : this.context.apkUrl ? 'apk-url' : 'apk-file';
+                return PHASE_WEIGHT_PROFILES[profile];
+            }
+        },
+        {
+            key: "compactUrl",
+            value: function compactUrl(value) {
+                try {
+                    var url = new URL(value);
+                    var path = url.pathname === '/' ? '' : url.pathname;
+                    return "".concat(url.host).concat(path);
+                } catch (e) {
+                    return value;
+                }
+            }
+        },
+        {
+            key: "fitToWidth",
+            value: function fitToWidth(value) {
+                var _this_stream_columns;
+                var width = (_this_stream_columns = this.stream.columns) !== null && _this_stream_columns !== void 0 ? _this_stream_columns : 100;
+                if (width <= 3) {
+                    return value.slice(0, Math.max(0, width));
+                }
+                return value.length <= width ? value : "".concat(value.slice(0, width - 3), "...");
+            }
+        },
+        {
+            key: "truncateMiddle",
+            value: function truncateMiddle(value, maxLength) {
+                if (value.length <= maxLength) {
+                    return value;
+                }
+                if (maxLength <= 3) {
+                    return value.slice(0, maxLength);
+                }
+                var startLength = Math.ceil((maxLength - 3) / 2);
+                var endLength = Math.floor((maxLength - 3) / 2);
+                return "".concat(value.slice(0, startLength), "...").concat(value.slice(-endLength));
+            }
+        },
+        {
+            key: "readString",
+            value: function readString(metadata, key) {
+                var value = metadata === null || metadata === void 0 ? void 0 : metadata[key];
+                return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+            }
+        },
+        {
+            key: "readNumber",
+            value: function readNumber(metadata, key) {
+                var value = metadata === null || metadata === void 0 ? void 0 : metadata[key];
+                return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+            }
+        },
+        {
+            key: "readProgress",
+            value: function readProgress(metadata, key) {
+                var value = this.readNumber(metadata, key);
+                if (value === undefined) {
+                    return undefined;
+                }
+                if (value > 1) {
+                    return Math.max(0, Math.min(1, value / 100));
+                }
+                return Math.max(0, Math.min(1, value));
+            }
+        },
+        {
+            key: "readByteProgress",
+            value: function readByteProgress(metadata) {
+                var bytesUploaded = this.readNumber(metadata, 'bytesUploaded');
+                var _this_readNumber;
+                var bytesTotal = (_this_readNumber = this.readNumber(metadata, 'bytesTotal')) !== null && _this_readNumber !== void 0 ? _this_readNumber : this.readNumber(metadata, 'fileSize');
+                if (bytesUploaded === undefined || bytesTotal === undefined || bytesTotal <= 0) {
+                    return undefined;
+                }
+                return Math.max(0, Math.min(1, bytesUploaded / bytesTotal));
+            }
+        },
+        {
+            key: "formatBytes",
+            value: function formatBytes(value) {
+                if (value < 1024) {
+                    return "".concat(Math.round(value), " B");
+                }
+                var units = [
+                    'KB',
+                    'MB',
+                    'GB',
+                    'TB'
+                ];
+                var size = value;
+                var unitIndex = -1;
+                do {
+                    size /= 1024;
+                    unitIndex += 1;
+                }while (size >= 1024 && unitIndex < units.length - 1);
+                var digits = size >= 100 ? 0 : size >= 10 ? 1 : 2;
+                return "".concat(size.toFixed(digits), " ").concat(units[unitIndex]);
+            }
+        }
+    ]);
+    return PublicationProgressReporter;
+}();