@skrr-ai/cli 0.1.91 → 0.1.93

package/dist/lib/store-listing.d.ts

@@ -0,0 +1,45 @@
+import { type ReleaseCapabilityManifestView, type StoreAgentInstallFunnelSummary, type StoreAgentReleaseAdoptionSummary, type StoreAgentReleaseOutcomes } from '@skrr-ai/data-provider';
+/**
+ * Terminal wording for a Store listing (`skrr store show`) and its publisher
+ * readouts (`skrr store stats`). Pure functions, so the commands only fetch
+ * and print and every sentence here is pinned by a unit test.
+ *
+ * Two rules carried over from the web surfaces, because a terminal is not a
+ * licence to say less:
+ *
+ *   - The capability manifest is a DISCLOSURE. Nothing narrows a run to it
+ *     (see `client/src/components/Store/capabilityDisclosure.ts`), so no line
+ *     here says an agent is limited, restricted or "can only" do something.
+ *     `Unrestricted` is the one state word, and it names the BAD case.
+ *   - A k-anonymous readout below its floor has NO figures. It is printed as
+ *     "withheld" with the floor it missed, never as 0 — a zero is a claim that
+ *     nobody did the thing, and the server did not make that claim.
+ */
+/** A listing's price in token credits (1,000,000 = $1), as the Store states it. */
+export declare function formatListingPrice(price: number | null | undefined): string;
+/** `4.6 ★ (12 ratings)`, or `No ratings yet` — never `0.0` for an unrated listing. */
+export declare function formatListingRating(rating: number | null | undefined, count: number | null | undefined): string;
+/**
+ * What the listed release is configured to use, as `label: value` pairs.
+ *
+ * `unavailable` stays its own answer — "we could not tell" — and is never
+ * rendered as an empty manifest, which would read as "uses nothing".
+ */
+export declare function capabilityDisclosureRows(view: ReleaseCapabilityManifestView | null | undefined): Array<[string, string]>;
+/** One sentence that keeps the disclosure from being read as a sandbox. */
+export declare const CAPABILITY_DISCLOSURE_FOOTNOTE = "Recorded by the platform when the release was created. A disclosure of its configuration \u2014 not a limit on what a run may do.";
+/** Align `label: value` pairs under a section, indented two spaces. */
+export declare function labelledLines(rows: ReadonlyArray<readonly [string, string]>): string[];
+/** `withheld: fewer than 5 buyers in this window` — the floor, never a zero. */
+export declare function withheldLine(minimumCohort: number, unit: string): string;
+export declare function formatRate(value: number | null | undefined): string;
+export declare function funnelWindowLine(summary: StoreAgentInstallFunnelSummary): string;
+export declare function adoptionWindowLine(summary: StoreAgentReleaseAdoptionSummary): string;
+export declare function outcomesWindowLine(outcomes: StoreAgentReleaseOutcomes): string;
+/**
+ * Small cells that were withheld from an otherwise reported readout. Said
+ * once, with the floor, so a short table is not mistaken for a complete one.
+ */
+export declare function suppressedCellsLine(cells: Record<string, number>, minimumCohort: number, unit: string): string | null;
+/** An exclusion count; `null` is "some, from too few buyers to say how many". */
+export declare function exclusionValue(value: number | null | undefined): string;

package/dist/lib/store-listing.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAPABILITY_DISCLOSURE_FOOTNOTE = void 0;
+exports.formatListingPrice = formatListingPrice;
+exports.formatListingRating = formatListingRating;
+exports.capabilityDisclosureRows = capabilityDisclosureRows;
+exports.labelledLines = labelledLines;
+exports.withheldLine = withheldLine;
+exports.formatRate = formatRate;
+exports.funnelWindowLine = funnelWindowLine;
+exports.adoptionWindowLine = adoptionWindowLine;
+exports.outcomesWindowLine = outcomesWindowLine;
+exports.suppressedCellsLine = suppressedCellsLine;
+exports.exclusionValue = exclusionValue;
+const data_provider_1 = require("@skrr-ai/data-provider");
+/**
+ * Terminal wording for a Store listing (`skrr store show`) and its publisher
+ * readouts (`skrr store stats`). Pure functions, so the commands only fetch
+ * and print and every sentence here is pinned by a unit test.
+ *
+ * Two rules carried over from the web surfaces, because a terminal is not a
+ * licence to say less:
+ *
+ *   - The capability manifest is a DISCLOSURE. Nothing narrows a run to it
+ *     (see `client/src/components/Store/capabilityDisclosure.ts`), so no line
+ *     here says an agent is limited, restricted or "can only" do something.
+ *     `Unrestricted` is the one state word, and it names the BAD case.
+ *   - A k-anonymous readout below its floor has NO figures. It is printed as
+ *     "withheld" with the floor it missed, never as 0 — a zero is a claim that
+ *     nobody did the thing, and the server did not make that claim.
+ */
+/** A listing's price in token credits (1,000,000 = $1), as the Store states it. */
+function formatListingPrice(price) {
+    return (0, data_provider_1.formatStoreAcquisitionPrice)(price);
+}
+/** `4.6 ★ (12 ratings)`, or `No ratings yet` — never `0.0` for an unrated listing. */
+function formatListingRating(rating, count) {
+    const ratings = Number(count) || 0;
+    if (ratings <= 0)
+        return 'No ratings yet';
+    return `${(Number(rating) || 0).toFixed(1)} / 5 (${ratings} rating${ratings === 1 ? '' : 's'})`;
+}
+const UNAVAILABLE_REASON = {
+    not_recorded: 'no capability record was stored for this release',
+    digest_mismatch: 'the stored record describes a different configuration, so it is not shown',
+    no_release: 'the listing has no approved public release',
+};
+const SHARED_DATA = {
+    none: 'None — you start from a blank agent',
+    bootstrap: "The publisher's bootstrap files are offered with the agent",
+    memory: "The publisher's shared memories are offered with the agent",
+    full: "The publisher's bootstrap files and shared memories are offered with the agent",
+};
+function listOrNone(items, none = 'None named') {
+    return items.length > 0 ? items.join(', ') : none;
+}
+/** A permission dimension: a wildcard entry means it is not narrowed at all. */
+function permissionValue(items) {
+    if (items.some(data_provider_1.isUnrestrictedCapabilityEntry)) {
+        const named = items.filter((entry) => !(0, data_provider_1.isUnrestrictedCapabilityEntry)(entry));
+        return named.length > 0 ? `Unrestricted (also names: ${named.join(', ')})` : 'Unrestricted';
+    }
+    return listOrNone(items);
+}
+/**
+ * What the listed release is configured to use, as `label: value` pairs.
+ *
+ * `unavailable` stays its own answer — "we could not tell" — and is never
+ * rendered as an empty manifest, which would read as "uses nothing".
+ */
+function capabilityDisclosureRows(view) {
+    if (!view) {
+        return [['Disclosure', 'Not available — this server did not send one']];
+    }
+    if (view.status !== 'available') {
+        return [['Disclosure', `Not available — ${UNAVAILABLE_REASON[view.reason] ?? view.reason}`]];
+    }
+    const m = view.manifest;
+    const rows = [];
+    rows.push([
+        'Platform capabilities',
+        m.platformCapabilities.mode === 'unrestricted'
+            ? 'Unrestricted — chosen per request'
+            : m.platformCapabilities.mode === 'not_loaded'
+                ? 'Not loaded by its tool policy'
+                : listOrNone(m.platformCapabilities.capabilities),
+    ]);
+    rows.push([
+        'Built-in tools',
+        m.builtinTools.mode === 'platform_default'
+            ? 'Platform default set (includes a shell and web access)'
+            : m.builtinTools.mode === 'none'
+                ? 'None'
+                : listOrNone(m.builtinTools.tools),
+    ]);
+    rows.push(['Tools', permissionValue(m.permissionManifest.tools)]);
+    rows.push(['Connectors', permissionValue(m.permissionManifest.connectors)]);
+    rows.push(['Network', permissionValue(m.permissionManifest.networkDomains)]);
+    rows.push(['Data', permissionValue(m.permissionManifest.dataScopes)]);
+    rows.push(['Secrets', permissionValue(m.permissionManifest.secretNames)]);
+    const delegation = m.delegation;
+    let delegationValue;
+    switch (delegation.mode) {
+        case 'none':
+            delegationValue = 'None';
+            break;
+        case 'all':
+            delegationValue = 'Unrestricted — any agent in its network';
+            break;
+        case 'not_loaded':
+            delegationValue = 'Not loaded by its tool policy';
+            break;
+        default:
+            delegationValue = listOrNone(delegation.agentIds);
+    }
+    if (delegation.includesPublicAgents && delegation.mode !== 'none') {
+        delegationValue += ' (includes public agents)';
+    }
+    rows.push(['Delegates to', delegationValue]);
+    const model = [m.model.provider, m.model.model].filter(Boolean).join(' / ');
+    rows.push(['Model', model || 'Not stated']);
+    const autonomy = [];
+    if (m.proactive.enabled) {
+        const watches = [...m.proactive.sources, ...m.proactive.watchers];
+        autonomy.push(watches.length > 0
+            ? `Acts on its own schedule after install (watches: ${watches.join(', ')})`
+            : 'Acts on its own schedule after install');
+    }
+    if (m.firstContact)
+        autonomy.push('Starts a conversation shortly after install');
+    rows.push(['Acts on its own', autonomy.length > 0 ? autonomy.join('; ') : 'No']);
+    rows.push(['Shared data', SHARED_DATA[m.sharedData] ?? m.sharedData]);
+    return rows;
+}
+/** One sentence that keeps the disclosure from being read as a sandbox. */
+exports.CAPABILITY_DISCLOSURE_FOOTNOTE = 'Recorded by the platform when the release was created. A disclosure of its configuration — not a limit on what a run may do.';
+/** Align `label: value` pairs under a section, indented two spaces. */
+function labelledLines(rows) {
+    const width = Math.max(0, ...rows.map(([label]) => label.length)) + 1;
+    return rows.map(([label, value]) => `  ${`${label}:`.padEnd(width + 1)}${value}`);
+}
+// ─── Publisher readouts (`skrr store stats`) ────────────────────────────────
+/** `withheld: fewer than 5 buyers in this window` — the floor, never a zero. */
+function withheldLine(minimumCohort, unit) {
+    return `withheld: fewer than ${minimumCohort} ${unit} in this window, so no figures are shown`;
+}
+function formatRate(value) {
+    if (value === null || value === undefined || !Number.isFinite(Number(value)))
+        return '-';
+    return `${Math.round(Number(value) * 100)}%`;
+}
+function day(value) {
+    return value ? String(value).slice(0, 10) : '?';
+}
+function funnelWindowLine(summary) {
+    return `${summary.days}-day window, ${day(summary.since)} to ${day(summary.until)} (UTC, complete days)`;
+}
+function adoptionWindowLine(summary) {
+    return `copies acquired before ${day(summary.until)} (UTC)`;
+}
+function outcomesWindowLine(outcomes) {
+    return `${outcomes.windowDays}-day window, ${day(outcomes.since)} to ${day(outcomes.until)} (UTC)`;
+}
+/**
+ * Small cells that were withheld from an otherwise reported readout. Said
+ * once, with the floor, so a short table is not mistaken for a complete one.
+ */
+function suppressedCellsLine(cells, minimumCohort, unit) {
+    const parts = Object.entries(cells)
+        .filter(([, count]) => Number(count) > 0)
+        .map(([name, count]) => `${count} ${humanize(name)}`);
+    if (parts.length === 0)
+        return null;
+    return `Withheld rows (fewer than ${minimumCohort} ${unit} each): ${parts.join(', ')}.`;
+}
+function humanize(key) {
+    return key.replace(/([a-z])([A-Z])/g, '$1 $2').toLowerCase();
+}
+/** An exclusion count; `null` is "some, from too few buyers to say how many". */
+function exclusionValue(value) {
+    if (value === null)
+        return 'some (too few buyers to count)';
+    if (value === undefined)
+        return '-';
+    return String(value);
+}

package/dist/lib/task-batch.d.ts

@@ -0,0 +1,67 @@
+import { type TaskBatchItemResult, type TaskBatchPatchItem } from '@skrr-ai/data-provider';
+export type ApiFailure = {
+    message: string;
+    status?: number;
+    code?: string;
+    retryable: boolean;
+};
+/** Normalize a thrown API error (or a per-item batch error) into one shape. */
+export declare function describeApiFailure(err: unknown): ApiFailure;
+/**
+ * A server that predates the batch routes answers 404 (no such POST route) or
+ * 405. A processed batch is ALWAYS a 200 (or 400/413/429 with a code), so a
+ * bare 404/405 on the batch call itself means "route missing", never "task
+ * not found".
+ */
+export declare function isBatchRouteMissing(err: unknown): boolean;
+export declare function chunkItems<T>(items: T[], size?: number): T[][];
+/**
+ * Same chunk, same key: a retry of an interrupted command replays the stored
+ * result instead of creating twice. The key is a fingerprint of the items, so a
+ * DIFFERENT chunk can never collide with it (the server answers 422 on a key
+ * reused with a different body).
+ */
+export declare function batchIdempotencyKey(kind: 'create' | 'patch', items: unknown[]): string;
+export type BatchCreateNode = {
+    key: string;
+    parentKey?: string;
+    payload: Record<string, unknown>;
+};
+export type BatchCreatedRow = {
+    key: string;
+    id: string;
+    identifier?: string;
+    /** `created` now, or `exists` when an earlier attempt already made it. */
+    status: 'created' | 'exists';
+    externalKey?: string;
+};
+export type BatchCreateFailure = {
+    key: string;
+    /** Not attempted because its parent was not created (or an earlier chunk failed). */
+    skipped: boolean;
+    error: ApiFailure;
+};
+export type BatchCreateOutcome = {
+    supported: false;
+} | {
+    supported: true;
+    rows: BatchCreatedRow[];
+    failures: BatchCreateFailure[];
+};
+/**
+ * Create `nodes` (parents before children) in chunks. `mapping` holds key -> id
+ * for nodes that already exist and is extended in place. Stops after the first
+ * chunk that reports a failure, as the serial path stopped at its first failure.
+ */
+export declare function createNodesViaBatch(nodes: BatchCreateNode[], mapping: Record<string, string>): Promise<BatchCreateOutcome>;
+export type BatchPatchOutcome = {
+    supported: false;
+} | {
+    supported: true;
+    results: TaskBatchItemResult[];
+};
+/**
+ * Apply `updates` in chunks; `results[i]` answers `updates[i]`. A chunk the
+ * server never processed is reported `skipped` for every row rather than lost.
+ */
+export declare function patchTasksViaBatch(updates: TaskBatchPatchItem[]): Promise<BatchPatchOutcome>;

package/dist/lib/task-batch.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeApiFailure = describeApiFailure;
+exports.isBatchRouteMissing = isBatchRouteMissing;
+exports.chunkItems = chunkItems;
+exports.batchIdempotencyKey = batchIdempotencyKey;
+exports.createNodesViaBatch = createNodesViaBatch;
+exports.patchTasksViaBatch = patchTasksViaBatch;
+/**
+ * Domain lib for `POST|PATCH /api/tasks/batch` (docs/architecture/task-batch-api-2026-10-08.md).
+ *
+ * `tasks create-tree` and `tasks bulk-update` reach the batch routes through
+ * `dataService.createTasksBatch|updateTasksBatch` and nothing else. This file owns
+ * the parts a command should not restate: chunking at the server cap, a
+ * deterministic idempotency key per chunk, tempId translation, and the "this
+ * server has no batch route" signal that sends a command back to its serial path.
+ */
+const node_crypto_1 = require("node:crypto");
+const data_provider_1 = require("@skrr-ai/data-provider");
+/** Normalize a thrown API error (or a per-item batch error) into one shape. */
+function describeApiFailure(err) {
+    const e = err;
+    let code = e.code;
+    let message = e.message ?? String(err);
+    if (e.body) {
+        try {
+            const parsed = JSON.parse(e.body);
+            code = parsed.code ?? code;
+            message = parsed.message ?? parsed.error ?? message;
+        }
+        catch {
+            /* non-JSON body */
+        }
+    }
+    const status = e.status;
+    return {
+        message,
+        ...(status ? { status } : {}),
+        ...(code ? { code } : {}),
+        retryable: status === 408 || status === 425 || status === 429 || (status ?? 0) >= 500,
+    };
+}
+/**
+ * A server that predates the batch routes answers 404 (no such POST route) or
+ * 405. A processed batch is ALWAYS a 200 (or 400/413/429 with a code), so a
+ * bare 404/405 on the batch call itself means "route missing", never "task
+ * not found".
+ */
+function isBatchRouteMissing(err) {
+    const status = err?.status;
+    return status === 404 || status === 405;
+}
+function chunkItems(items, size = data_provider_1.TASK_BATCH_MAX_ITEMS ?? 100) {
+    const out = [];
+    for (let i = 0; i < items.length; i += size)
+        out.push(items.slice(i, i + size));
+    return out;
+}
+/**
+ * Same chunk, same key: a retry of an interrupted command replays the stored
+ * result instead of creating twice. The key is a fingerprint of the items, so a
+ * DIFFERENT chunk can never collide with it (the server answers 422 on a key
+ * reused with a different body).
+ */
+function batchIdempotencyKey(kind, items) {
+    const digest = (0, node_crypto_1.createHash)('sha256').update((0, data_provider_1.stableJson)(items)).digest('hex').slice(0, 40);
+    return `cli-${kind}-batch:${digest}`;
+}
+/**
+ * Create `nodes` (parents before children) in chunks. `mapping` holds key -> id
+ * for nodes that already exist and is extended in place. Stops after the first
+ * chunk that reports a failure, as the serial path stopped at its first failure.
+ */
+async function createNodesViaBatch(nodes, mapping) {
+    const rows = [];
+    const failures = [];
+    for (const [chunkIndex, chunk] of chunkItems(nodes).entries()) {
+        const inChunk = new Map(chunk.map((node, i) => [node.key, `n${i}`]));
+        const items = [];
+        const sent = [];
+        for (const [i, node] of chunk.entries()) {
+            const { parentId: _ignored, ...payload } = node.payload;
+            const item = { ...payload, tempId: `n${i}` };
+            if (node.parentKey) {
+                const sameChunk = inChunk.get(node.parentKey);
+                if (sameChunk)
+                    item.parentTempId = sameChunk;
+                else if (mapping[node.parentKey])
+                    item.parentId = mapping[node.parentKey];
+                else {
+                    failures.push({
+                        key: node.key,
+                        skipped: true,
+                        error: {
+                            message: `Parent "${node.parentKey}" was not created, so "${node.key}" was not attempted`,
+                            code: 'BATCH_PARENT_NOT_CREATED',
+                            retryable: false,
+                        },
+                    });
+                    continue;
+                }
+            }
+            else if (node.payload.parentId) {
+                item.parentId = node.payload.parentId;
+            }
+            items.push(item);
+            sent.push(node);
+        }
+        if (items.length === 0)
+            break;
+        let response;
+        try {
+            response = await data_provider_1.dataService.createTasksBatch(items, {
+                idempotencyKey: batchIdempotencyKey('create', items),
+            });
+        }
+        catch (err) {
+            if (chunkIndex === 0 && isBatchRouteMissing(err))
+                return { supported: false };
+            failures.push({ key: sent[0].key, skipped: false, error: describeApiFailure(err) });
+            for (const node of sent.slice(1)) {
+                failures.push({
+                    key: node.key,
+                    skipped: true,
+                    error: {
+                        message: `Not attempted: the batch request containing "${sent[0].key}" failed`,
+                        code: 'BATCH_NOT_ATTEMPTED',
+                        retryable: true,
+                    },
+                });
+            }
+            break;
+        }
+        let failed = false;
+        for (const [i, result] of response.results.entries()) {
+            const node = sent[i];
+            if (!node)
+                continue;
+            if (result.ok && result.id) {
+                mapping[node.key] = result.id;
+                rows.push({
+                    key: node.key,
+                    id: result.id,
+                    ...(result.identifier ? { identifier: result.identifier } : {}),
+                    status: result.status === 'exists' ? 'exists' : 'created',
+                    ...(result.externalKey ? { externalKey: result.externalKey } : {}),
+                });
+            }
+            else {
+                failed = true;
+                failures.push({
+                    key: node.key,
+                    skipped: result.status === 'skipped',
+                    error: result.error
+                        ? {
+                            message: result.error.message,
+                            status: result.error.status,
+                            code: result.error.code,
+                            retryable: result.error.retryable,
+                        }
+                        : { message: 'Task was not created', retryable: false },
+                });
+            }
+        }
+        if (failed)
+            break;
+    }
+    return { supported: true, rows, failures };
+}
+/**
+ * Apply `updates` in chunks; `results[i]` answers `updates[i]`. A chunk the
+ * server never processed is reported `skipped` for every row rather than lost.
+ */
+async function patchTasksViaBatch(updates) {
+    const results = [];
+    let aborted = null;
+    let offset = 0;
+    for (const [chunkIndex, chunk] of chunkItems(updates).entries()) {
+        if (aborted) {
+            for (const [i, update] of chunk.entries()) {
+                results.push({
+                    index: offset + i,
+                    id: update.id,
+                    ok: false,
+                    status: 'skipped',
+                    error: {
+                        status: aborted.status ?? 0,
+                        code: 'BATCH_NOT_ATTEMPTED',
+                        message: 'Not attempted: an earlier batch request failed',
+                        retryable: true,
+                    },
+                });
+            }
+            offset += chunk.length;
+            continue;
+        }
+        try {
+            const response = await data_provider_1.dataService.updateTasksBatch(chunk, {
+                idempotencyKey: batchIdempotencyKey('patch', chunk),
+            });
+            for (const [i, result] of response.results.entries()) {
+                results.push({ ...result, index: offset + i });
+            }
+        }
+        catch (err) {
+            if (chunkIndex === 0 && isBatchRouteMissing(err))
+                return { supported: false };
+            aborted = describeApiFailure(err);
+            for (const [i, update] of chunk.entries()) {
+                results.push({
+                    index: offset + i,
+                    id: update.id,
+                    ok: false,
+                    status: 'failed',
+                    error: {
+                        status: aborted.status ?? 0,
+                        code: aborted.code ?? 'BATCH_REQUEST_FAILED',
+                        message: aborted.message,
+                        retryable: aborted.retryable,
+                    },
+                });
+            }
+        }
+        offset += chunk.length;
+    }
+    return { supported: true, results };
+}

package/dist/lib/terminal-qr.d.ts

@@ -0,0 +1,55 @@
+/**
+ * A QR code a phone can scan off a terminal.
+ *
+ * The ENCODER is `qrcode-terminal`'s vendored QR model (the same zero-dependency
+ * package the daemon already ships for its login QR, pinned in the lockfile).
+ * Its own renderer is not used, because it is the part that decides whether a
+ * phone can read the result, and it gets two things wrong for that:
+ *
+ *  - a ONE-module border. The QR spec asks for a four-module quiet zone, and a
+ *    scanner looking at a terminal full of other text needs it most;
+ *  - it paints light modules as `█` in the terminal's FOREGROUND colour, so on
+ *    a light-themed terminal the code comes out inverted, which many scanners
+ *    refuse.
+ *
+ * This renderer draws half-blocks (two modules per character row, so the code
+ * is square in a ~1:2 character cell) in EXPLICIT colours — black on bright
+ * white — so it scans the same on dark and light themes, with a full quiet zone.
+ *
+ * The QR is always a convenience printed beside the URL, never instead of it:
+ * `qrRenderDecision` says no for a pipe, `NO_COLOR`, `OVERSKY_NO_QR` / `SKRR_NO_QR`
+ * or a terminal too narrow to hold it, and the caller prints the URL alone.
+ */
+/** The spec's quiet zone, in modules. */
+export declare const QR_QUIET_ZONE = 4;
+/**
+ * The module matrix for `text`, quiet zone included. Level M: a share URL is
+ * well under 100 bytes, so the extra damage tolerance costs nothing in size.
+ */
+export declare function qrMatrix(text: string, level?: 'L' | 'M' | 'Q' | 'H'): boolean[][];
+/**
+ * Render with half blocks: the upper half of each character is the top
+ * module (foreground, black), the lower half the bottom module (background,
+ * white). Returns the lines, each `matrix width` characters wide.
+ */
+export declare function renderQr(text: string): string[];
+/** The QR's width in terminal columns (one column per module). */
+export declare function qrWidth(text: string): number;
+export type QrRenderDecision = {
+    render: true;
+} | {
+    render: false;
+    reason: string;
+};
+/**
+ * Whether a QR for `text` can be drawn on `stream`. Default-deny when the
+ * stream does not say it is a TTY, so captured output never carries block
+ * glyphs or escape codes.
+ */
+export declare function qrRenderDecision(text: string, { env, stream, }?: {
+    env?: NodeJS.ProcessEnv;
+    stream?: {
+        isTTY?: boolean;
+        columns?: number;
+    };
+}): QrRenderDecision;