hotcodepush 0.0.1 → 0.1.0

package/dist/commands/channel/pause.js

@@ -0,0 +1,32 @@
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+import { channelOptionShape, fetchChannel, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Pause a channel, the kill switch: it serves nothing new until resumed.',
+    examples: [
+        'hotcodepush channel pause --channel production',
+        'hotcodepush channel pause --channel production --yes --json',
+    ],
+    options: defineCommandOptions(channelOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedChannel = await fetchChannel(hotCodePush, options);
+        const isConfirmed = await confirmConsequence(`pauses channel ${fetchedChannel.name}: devices keep what they have and get nothing new`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        const pausedChannel = await hotCodePush.apps.channels.pause({
+            appId: fetchedChannel.appId,
+            channelId: fetchedChannel.id,
+        });
+        if (options.json) {
+            printJson(pausedChannel);
+        }
+        else {
+            console.log(`Paused channel ${pausedChannel.name} (${pausedChannel.id}).`);
+        }
+    },
+});

package/dist/commands/channel/resume.js

@@ -0,0 +1,32 @@
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+import { channelOptionShape, fetchChannel, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Resume a paused channel: it serves its releases again.',
+    examples: [
+        'hotcodepush channel resume --channel production',
+        'hotcodepush channel resume --channel production --yes --json',
+    ],
+    options: defineCommandOptions(channelOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const fetchedChannel = await fetchChannel(hotCodePush, options);
+        const isConfirmed = await confirmConsequence(`resumes channel ${fetchedChannel.name}: devices receive its releases again`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        const resumedChannel = await hotCodePush.apps.channels.resume({
+            appId: fetchedChannel.appId,
+            channelId: fetchedChannel.id,
+        });
+        if (options.json) {
+            printJson(resumedChannel);
+        }
+        else {
+            console.log(`Resumed channel ${resumedChannel.name} (${resumedChannel.id}).`);
+        }
+    },
+});

package/dist/commands/channel/update.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { channelFieldsClearShape, channelFieldsShape, resolveChannelFields, } from '../../utils/channel-fields.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { channelOptionShape, fetchChannel, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Rename a channel or change its flags, expiry and auto-pause policy.',
+    examples: [
+        'hotcodepush channel update --channel staging --protected',
+        'hotcodepush channel update --channel pr-42 --expires-in 7d --json',
+    ],
+    options: defineCommandOptions({
+        ...channelFieldsClearShape,
+        ...channelFieldsShape,
+        ...channelOptionShape,
+        name: z
+            .string()
+            .optional()
+            .describe("The channel's new name: letters, digits, - and _, one to 64 characters."),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const channelFields = resolveChannelFields(options);
+        const fetchedChannel = await fetchChannel(hotCodePush, options);
+        const updatedChannel = await hotCodePush.apps.channels.update({
+            ...channelFields,
+            appId: fetchedChannel.appId,
+            channelId: fetchedChannel.id,
+            name: options.name,
+        });
+        if (options.json) {
+            printJson(updatedChannel);
+        }
+        else {
+            console.log(`Updated channel ${updatedChannel.name} (${updatedChannel.id}).`);
+        }
+    },
+});

package/dist/commands/checkout/create.js

@@ -0,0 +1,25 @@
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: 'Enable billing on a free organization: create the checkout for pay-as-you-go and print its URL to open.',
+    examples: [
+        'hotcodepush checkout create',
+        'hotcodepush checkout create --organization Acme --json',
+    ],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const createdCheckout = await hotCodePush.organizations.checkouts.create({
+            organizationId: await fetchOrganizationId(hotCodePush, options),
+        });
+        if (options.json) {
+            printJson(createdCheckout);
+        }
+        else {
+            console.log(`Open the checkout to enable billing: ${createdCheckout.url}`);
+        }
+    },
+});

package/dist/commands/completion.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { COMPLETION_SHELLS, readCompletionScript, } from '../utils/completion/script-files.js';
+import { InvalidParameterError } from '../utils/errors.js';
+import { defineCommandOptions } from '../utils/global-options.js';
+import { printJson } from '../utils/output.js';
+import { promptSelect } from '../utils/prompts.js';
+// zodline reports an invalid argument as a plain error that would read as `unexpected`.
+// So the action checks the shell itself.
+const ShellSchema = z.enum(COMPLETION_SHELLS);
+export default defineCommand({
+    description: 'Print the completion script for <shell>, bash, fish or zsh: eval "$(hotcodepush completion <shell>)" loads it from ~/.bashrc, or from ~/.zshrc after compinit, and fish loads it saved as ~/.config/fish/completions/hotcodepush.fish.',
+    examples: [
+        'eval "$(hotcodepush completion zsh)"',
+        'hotcodepush completion fish > ~/.config/fish/completions/hotcodepush.fish',
+    ],
+    args: z.array(z.string()),
+    options: defineCommandOptions({}),
+    action: async (options, args) => {
+        if (args.length > 1) {
+            throw new InvalidParameterError(`The completion command takes one shell, <shell>. It does not take ${args.slice(1).join(' ')}.`);
+        }
+        const shell = args[0] ??
+            (await promptSelect('<shell>', 'Which shell is the completion script for?', ShellSchema.options.map(value => ({ label: value, value })), options));
+        const parsedShell = ShellSchema.safeParse(shell);
+        if (!parsedShell.success) {
+            throw new InvalidParameterError(`The shell ${shell} has no completion script.`, 'Pass bash, fish or zsh as <shell>.');
+        }
+        const script = await readCompletionScript(parsedShell.data);
+        if (options.json) {
+            printJson({ script });
+            return;
+        }
+        console.log(script);
+    },
+});

package/dist/commands/customer-portal-session/create.js

@@ -0,0 +1,25 @@
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { fetchOrganizationId } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: "Create a session of the customer portal for an organization's invoices and payment method, and print its URL to open.",
+    examples: [
+        'hotcodepush customer-portal-session create',
+        'hotcodepush customer-portal-session create --organization Acme --json',
+    ],
+    options: defineCommandOptions({}),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const createdSession = await hotCodePush.organizations.customerPortalSessions.create({
+            organizationId: await fetchOrganizationId(hotCodePush, options),
+        });
+        if (options.json) {
+            printJson(createdSession);
+        }
+        else {
+            console.log(`Open the customer portal for the invoices and the payment method: ${createdSession.url}`);
+        }
+    },
+});

package/dist/commands/device/delete.js

@@ -0,0 +1,29 @@
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { deviceOptionShape, resolveDeviceReference, } from '../../utils/device-resolution.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson } from '../../utils/output.js';
+import { confirmConsequence } from '../../utils/prompts.js';
+export default defineCommand({
+    description: "Delete a device's record, an erasure request; the device reports again with its next check.",
+    examples: [
+        'hotcodepush device delete --device 6b1e9d37-2f5c-4a80-9c46-d8e3a1f7b259',
+        'hotcodepush device delete --device 6b1e9d37-2f5c-4a80-9c46-d8e3a1f7b259 --yes --json',
+    ],
+    options: defineCommandOptions(deviceOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const { appId, deviceId } = await resolveDeviceReference(hotCodePush, options);
+        const isConfirmed = await confirmConsequence(`deletes device ${deviceId}'s record for good, the erasure request. The device reports again with its next check`, options);
+        if (!isConfirmed) {
+            return;
+        }
+        await hotCodePush.apps.devices.delete({ appId, deviceId });
+        if (options.json) {
+            printJson({ id: deviceId, name: null });
+        }
+        else {
+            console.log(`Deleted device ${deviceId}.`);
+        }
+    },
+});

package/dist/commands/device/get.js

@@ -0,0 +1,60 @@
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { deviceOptionShape, resolveDeviceReference, } from '../../utils/device-resolution.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printDetails, printJson, printTable, resolveDate, } from '../../utils/output.js';
+import { fetchAllPages } from '../../utils/pagination.js';
+import { resolveBinaryText } from './list.js';
+export default defineCommand({
+    description: 'Print what a device runs and reported last, with its outcome per release, newest first.',
+    examples: [
+        'hotcodepush device get --device 6b1e9d37-2f5c-4a80-9c46-d8e3a1f7b259',
+        'hotcodepush device get --device 6b1e9d37-2f5c-4a80-9c46-d8e3a1f7b259 --json',
+    ],
+    options: defineCommandOptions(deviceOptionShape),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const deviceReference = await resolveDeviceReference(hotCodePush, options);
+        const fetchedDevice = await hotCodePush.apps.devices.get({
+            ...deviceReference,
+            relations: ['channel'],
+        });
+        const fetchedEvents = await fetchAllPages(page => hotCodePush.apps.devices.events.list({ ...deviceReference, ...page }));
+        if (options.json) {
+            printJson({ ...fetchedDevice, events: fetchedEvents });
+            return;
+        }
+        printDetails([
+            ['ID', fetchedDevice.deviceId],
+            ['Platform', `${fetchedDevice.platform} ${fetchedDevice.osVersion}`],
+            ['Binary', resolveBinaryText(fetchedDevice)],
+            ['Fingerprint', fetchedDevice.fingerprint ?? 'none'],
+            [
+                'Channel',
+                `${fetchedDevice.channel?.name ?? fetchedDevice.channelId ?? 'none'} (${fetchedDevice.channelSource})`,
+            ],
+            ['Release', fetchedDevice.currentReleaseId ?? 'the embedded bundle'],
+            ['SDK', fetchedDevice.sdkVersion],
+            [
+                'Attributes',
+                Object.entries(fetchedDevice.attributes)
+                    .map(([key, value]) => `${key}=${value}`)
+                    .join(', ') || 'none',
+            ],
+            ['Country', fetchedDevice.country ?? 'unknown'],
+            ['Last seen', fetchedDevice.lastSeenAt],
+            ['First seen', fetchedDevice.createdAt],
+        ]);
+        printTable({
+            emptyText: 'No outcomes yet: the device has not checked a release.',
+            headers: ['RELEASE', 'OUTCOME', 'REASON', 'DATE'],
+            nextOffset: null,
+            rows: fetchedEvents.map(({ createdAt, reason, releaseId, type }) => [
+                releaseId,
+                type,
+                reason ?? '',
+                resolveDate(createdAt),
+            ]),
+        });
+    },
+});

package/dist/commands/device/list.js

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { resolveTimeBound } from '../../utils/duration.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { printJson, printTable, resolveDate } from '../../utils/output.js';
+import { paginationShape, resolveNextOffset } from '../../utils/pagination.js';
+import { readProjectConfig } from '../../utils/project-config.js';
+import { fetchAppId, fetchChannels, fetchResourceId, } from '../../utils/resource-resolution.js';
+export default defineCommand({
+    description: "List the app's devices, the newest report first, filtered by what they reported; support and QA, never a pipeline.",
+    examples: [
+        'hotcodepush device list --attribute userId=42',
+        'hotcodepush device list --platform ios --binary-version 2.4.1 --last-seen-since 2026-09-01T00:00:00Z --json',
+    ],
+    options: defineCommandOptions({
+        ...paginationShape,
+        attribute: z
+            .string()
+            .optional()
+            .describe('An attribute the app set, key=value, such as userId=42.'),
+        binaryBuild: z
+            .string()
+            .optional()
+            .describe('The build number the devices run.'),
+        binaryVersion: z
+            .string()
+            .optional()
+            .describe('The app version the devices run.'),
+        channel: z
+            .string()
+            .optional()
+            .describe('The channel the devices follow, by id or name.'),
+        fingerprint: z
+            .string()
+            .optional()
+            .describe('The native fingerprint the devices report.'),
+        lastSeenSince: z
+            .string()
+            .optional()
+            .describe('The earliest last report, inclusive: an ISO 8601 timestamp or a duration ago such as 2h or 7d.'),
+        lastSeenUntil: z
+            .string()
+            .optional()
+            .describe('The latest last report, inclusive: an ISO 8601 timestamp or a duration ago such as 2h or 7d.'),
+        platform: z
+            .enum(['android', 'ios'])
+            .optional()
+            .describe('The platform, ios or android.'),
+        sdkVersion: z
+            .string()
+            .optional()
+            .describe('The SDK version the devices run.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const appId = await fetchAppId(hotCodePush, options, readProjectConfig(options.config));
+        const listedDevices = await hotCodePush.apps.devices.list({
+            appId,
+            attribute: options.attribute,
+            binaryBuild: options.binaryBuild,
+            binaryVersion: options.binaryVersion,
+            channelId: options.channel === undefined
+                ? undefined
+                : await fetchResourceId('channel', options.channel, () => fetchChannels(hotCodePush, appId)),
+            fingerprint: options.fingerprint,
+            lastSeenSince: resolveTimeBound(options.lastSeenSince),
+            lastSeenUntil: resolveTimeBound(options.lastSeenUntil),
+            limit: options.limit,
+            offset: options.offset,
+            platform: options.platform,
+            relations: ['channel'],
+            sdkVersion: options.sdkVersion,
+        });
+        const nextOffset = resolveNextOffset(listedDevices.length, options);
+        if (options.json) {
+            printJson({ devices: listedDevices, nextOffset });
+            return;
+        }
+        printTable({
+            emptyText: 'No devices match; a device appears with its first check.',
+            headers: ['ID', 'PLATFORM', 'BINARY', 'CHANNEL', 'SDK', 'LAST SEEN'],
+            nextOffset,
+            rows: listedDevices.map(device => [
+                device.deviceId,
+                device.platform,
+                resolveBinaryText(device),
+                device.channel?.name ?? device.channelId ?? 'none',
+                device.sdkVersion,
+                resolveDate(device.lastSeenAt),
+            ]),
+        });
+    },
+});
+export function resolveBinaryText({ binaryBuild, binaryVersion, }) {
+    return `${binaryVersion} (${binaryBuild})`;
+}

package/dist/commands/device/probe.js

@@ -0,0 +1,253 @@
+import { ChannelIndexSchema, evaluateChannelIndex, } from '@hotcodepush/protocol';
+import { z } from 'zod';
+import { defineCommand } from 'zodline';
+import { createApiClient } from '../../utils/api-client.js';
+import { deviceOptionShape } from '../../utils/device-resolution.js';
+import { defineCommandOptions } from '../../utils/global-options.js';
+import { resolveFilesBaseUrl } from '../../utils/hosts.js';
+import { printDetails, printJson, printTable } from '../../utils/output.js';
+import { fetchAllPages } from '../../utils/pagination.js';
+import { readProjectConfig } from '../../utils/project-config.js';
+import { promptSelect, promptText } from '../../utils/prompts.js';
+import { resolveAttributePairs } from '../../utils/release-conditions.js';
+import { channelOptionShape, fetchAppId, fetchChannelId, } from '../../utils/resource-resolution.js';
+import { readApiUrl } from '../../utils/user-config.js';
+const INDEX_FETCH_TIMEOUT_MS = 30_000;
+// No release is older than the binary, so a device without a created binary has no floor.
+const NO_FLOOR = new Date(0).toISOString();
+export default defineCommand({
+    description: 'Answer why a device did not update: fetch the live index as a device would, evaluate it and mark every condition of every release.',
+    examples: [
+        'hotcodepush device probe --platform ios --binary-version 2.4.1 --binary-build 57',
+        'hotcodepush device probe --device 6b1e9d37-2f5c-4a80-9c46-d8e3a1f7b259 --json',
+    ],
+    options: defineCommandOptions({
+        ...channelOptionShape,
+        ...deviceOptionShape,
+        attribute: z
+            .array(z.string())
+            .optional()
+            .describe('An attribute the app sets, key=value, repeatable.'),
+        binaryBuild: z
+            .string()
+            .optional()
+            .describe("The store build's build number, CFBundleVersion or versionCode."),
+        binaryVersion: z
+            .string()
+            .optional()
+            .describe("The store build's version, CFBundleShortVersionString or versionName."),
+        platform: z
+            .enum(['android', 'ios'])
+            .optional()
+            .describe('The platform, ios or android.'),
+    }),
+    action: async (options) => {
+        const hotCodePush = createApiClient();
+        const projectConfig = readProjectConfig(options.config);
+        const appId = await fetchAppId(hotCodePush, options, projectConfig);
+        const fetchedDevice = options.device === undefined
+            ? undefined
+            : await hotCodePush.apps.devices.get({
+                appId,
+                deviceId: options.device,
+            });
+        const channel = await hotCodePush.apps.channels.get({
+            appId,
+            channelId: await fetchChannelId(hotCodePush, appId, {
+                ...options,
+                channel: options.channel ?? fetchedDevice?.channelId ?? undefined,
+            }, projectConfig),
+        });
+        const platform = options.platform ??
+            fetchedDevice?.platform ??
+            (await promptSelect('--platform', 'Which platform?', [
+                { label: 'iOS', value: 'ios' },
+                { label: 'Android', value: 'android' },
+            ], options));
+        const binaryVersion = options.binaryVersion ??
+            fetchedDevice?.binaryVersion ??
+            (await promptText('--binary-version', 'Which app version?', options));
+        const binaryBuild = options.binaryBuild ??
+            fetchedDevice?.binaryBuild ??
+            (await promptText('--binary-build', 'Which build number?', options));
+        const binary = (await fetchAllPages(page => hotCodePush.apps.binaries.list({ appId, ...page }))).find(candidate => candidate.platform === platform &&
+            candidate.version === binaryVersion &&
+            candidate.build === binaryBuild);
+        const servedIndex = await fetchServedIndex(appId, channel.id, platform);
+        const unknownFacts = resolveUnknownFacts(fetchedDevice, binary);
+        const builtAt = binary?.createdAt ?? null;
+        const device = {
+            attributes: {
+                ...fetchedDevice?.attributes,
+                ...Object.fromEntries(resolveAttributePairs(options.attribute).map(({ key, value }) => [
+                    key,
+                    value,
+                ])),
+            },
+            binaryBuild,
+            binaryVersion,
+            builtAt: builtAt ?? NO_FLOOR,
+            currentRelease: fetchedDevice === undefined
+                ? null
+                : await fetchCurrentRelease(hotCodePush, fetchedDevice, servedIndex),
+            deviceId: fetchedDevice?.deviceId ?? '',
+            failedBundleIds: fetchedDevice === undefined
+                ? []
+                : resolveFailedBundleIds(await fetchAllPages(page => hotCodePush.apps.devices.events.list({
+                    appId,
+                    deviceId: fetchedDevice.deviceId,
+                    ...page,
+                })), servedIndex.index),
+            fingerprint: fetchedDevice?.fingerprint ?? binary?.fingerprint ?? null,
+            osVersion: fetchedDevice?.osVersion ?? '',
+            reportedAt: fetchedDevice?.lastSeenAt ?? null,
+        };
+        const evaluation = servedIndex.index === null
+            ? null
+            : evaluateKnownFacts(servedIndex.index, device, unknownFacts);
+        if (options.json) {
+            printJson({
+                channelId: channel.id,
+                device: { ...device, builtAt },
+                outcome: evaluation?.outcome ?? null,
+                platform,
+                sequence: servedIndex.index?.sequence ?? null,
+                status: servedIndex.status,
+                unknownFacts,
+                url: servedIndex.url,
+                verdicts: evaluation?.verdicts ?? [],
+            });
+            return;
+        }
+        printDetails([
+            ['Channel', `${channel.name}, ${platform}`],
+            ['Index', resolveServedIndexText(servedIndex)],
+            [
+                'Outcome',
+                evaluation === null ? 'none' : resolveOutcomeText(evaluation),
+            ],
+            [
+                'Unknown',
+                unknownFacts.length === 0
+                    ? 'nothing'
+                    : `${unknownFacts.join(', ')}, treated as passing; pass --device for the facts of a real device`,
+            ],
+        ]);
+        if (evaluation !== null && servedIndex.index !== null) {
+            printTable({
+                emptyText: 'The index offers no release.',
+                headers: ['RELEASE', 'ROLLOUT', 'CONDITIONS', 'VERDICT'],
+                nextOffset: null,
+                rows: evaluation.verdicts.map(verdict => [
+                    `#${verdict.release.number}`,
+                    `${verdict.release.rolloutPercent}%`,
+                    resolveConditionsText(verdict, unknownFacts),
+                    verdict.isEligible
+                        ? 'eligible'
+                        : `${verdict.reason ?? 'skipped'}${verdict.conditionType === undefined ? '' : ` (${verdict.conditionType})`}`,
+                ]),
+            });
+        }
+    },
+});
+// The index may no longer carry the release, so its number then comes from the API.
+async function fetchCurrentRelease(hotCodePush, fetchedDevice, servedIndex) {
+    const releaseId = fetchedDevice.currentReleaseId;
+    if (releaseId === null) {
+        return null;
+    }
+    const indexRelease = servedIndex.index?.releases.find(({ id }) => id === releaseId);
+    const number = indexRelease?.number ??
+        (await hotCodePush.apps.releases.get({
+            appId: fetchedDevice.appId,
+            releaseId,
+        })).number;
+    return { id: releaseId, number };
+}
+// The same request a device makes.
+async function fetchServedIndex(appId, channelId, platform) {
+    const url = `${resolveFilesBaseUrl(readApiUrl())}/apps/${appId}/channels/${channelId}/${platform}/v1/index.json`;
+    const response = await fetch(url, {
+        signal: AbortSignal.timeout(INDEX_FETCH_TIMEOUT_MS),
+    });
+    if (!response.ok) {
+        await response.body?.cancel();
+        return { index: null, status: response.status, url };
+    }
+    return {
+        index: ChannelIndexSchema.parse(await response.json()),
+        status: response.status,
+        url,
+    };
+}
+// Rollouts count as reached and conditions on unknown facts as passing, so only known facts decide.
+function evaluateKnownFacts(index, device, unknownFacts) {
+    const releasesById = new Map(index.releases.map(release => [release.id, release]));
+    const knownIndex = {
+        ...index,
+        releases: index.releases.map(release => ({
+            ...release,
+            conditions: release.conditions.filter(({ type }) => !unknownFacts.includes(type)),
+            rolloutPercent: unknownFacts.includes('rollout')
+                ? 100
+                : release.rolloutPercent,
+        })),
+    };
+    const { outcome, verdicts } = evaluateChannelIndex(knownIndex, device);
+    const resolveServedRelease = (release) => releasesById.get(release.id) ?? release;
+    return {
+        outcome: outcome.release === null
+            ? outcome
+            : { ...outcome, release: resolveServedRelease(outcome.release) },
+        verdicts: verdicts.map(verdict => ({
+            ...verdict,
+            release: resolveServedRelease(verdict.release),
+        })),
+    };
+}
+function resolveConditionsText(verdict, unknownFacts) {
+    const knownVerdicts = [...verdict.conditions];
+    const conditionTexts = verdict.release.conditions.map(({ type }) => {
+        if (unknownFacts.includes(type)) {
+            return `${type} unknown`;
+        }
+        const conditionVerdict = knownVerdicts.shift();
+        return `${type} ${conditionVerdict?.isSatisfied ? 'pass' : 'fail'}`;
+    });
+    return conditionTexts.join(', ') || 'none';
+}
+function resolveFailedBundleIds(events, index) {
+    const failedReleaseIds = new Set(events
+        .filter(({ type }) => type === 'failed')
+        .map(({ releaseId }) => releaseId));
+    return (index?.releases ?? [])
+        .filter(({ id }) => failedReleaseIds.has(id))
+        .map(({ bundleId }) => bundleId);
+}
+function resolveOutcomeText({ outcome }) {
+    const releaseText = outcome.release === null
+        ? 'the embedded bundle'
+        : `release #${outcome.release.number}`;
+    switch (outcome.status) {
+        case 'available':
+            return `available, ${releaseText}${outcome.isMandatory ? ', mandatory' : ''}`;
+        case 'skipped':
+            return `skipped, ${outcome.reason}${outcome.conditionType === undefined ? '' : ` (${outcome.conditionType})`}, ${releaseText}`;
+        case 'up_to_date':
+            return `up_to_date, ${releaseText}`;
+    }
+}
+// The index sequence is the publish time in milliseconds.
+function resolveServedIndexText({ index, status, url }) {
+    return index === null
+        ? `none: HTTP ${status} at ${url}; a device gets no release`
+        : `published ${new Date(index.sequence).toISOString()}`;
+}
+function resolveUnknownFacts(fetchedDevice, binary) {
+    if (fetchedDevice !== undefined) {
+        return [];
+    }
+    return binary?.fingerprint === undefined || binary.fingerprint === null
+        ? ['fingerprint', 'os', 'rollout']
+        : ['os', 'rollout'];
+}