@indigoai-us/hq-cli 5.109.16 → 5.110.0

package/dist/lib/bot/owner-context.js

@@ -0,0 +1,151 @@
+/**
+ * Owner context: who the bot's owner is and which companies they belong to.
+ *
+ * A local bot runs under its OWN HQ identity (per-bot machine credentials set
+ * for the whole resident process, and inherited by the model subprocess). So
+ * any membership lookup the model makes with `hq` describes the bot, and a bot
+ * usually belongs to no company. Bots were reading that empty answer as "your
+ * owner has no company".
+ *
+ * The resident process (trusted code, not the model) looks the owner up with
+ * the owner's own cached HQ session, strictly non-interactively, and verifies
+ * the session really is the owner before trusting it. Only the result (company
+ * slugs, uids, roles) reaches the model; the owner's token never does. A failed
+ * lookup is reported as "could not check", never as "no companies".
+ */
+import { ensureCognitoToken } from "../../utils/cognito-session.js";
+import { resolveCallerPersonUid, vaultApiFetch } from "../../utils/vault-api.js";
+function message(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+export const defaultOwnerLookupIo = {
+    // tokenSource "person" never uses the bot's machine creds, even though
+    // HQ_MACHINE_CREDS_FILE is set for this process.
+    personToken: () => ensureCognitoToken({ tokenSource: "person", interactive: false }),
+    callerPersonUid: (token) => resolveCallerPersonUid(token),
+    memberships: async (token) => {
+        const res = await vaultApiFetch({ token, path: "/membership/me", signal: AbortSignal.timeout(15_000) });
+        if (!res.ok)
+            throw new Error(`membership lookup returned ${res.status}`);
+        const data = (await res.json());
+        if (!Array.isArray(data.memberships))
+            throw new Error("membership lookup returned no list");
+        return data.memberships;
+    },
+};
+export async function lookupOwnerContext(ownerUid, io = defaultOwnerLookupIo) {
+    const checkedAt = (io.now ?? (() => new Date()))().toISOString();
+    let token;
+    try {
+        token = await io.personToken();
+    }
+    catch (err) {
+        return { status: "unavailable", ownerUid, reason: `your owner's HQ sign-in on this computer is not usable (${message(err)})`, checkedAt };
+    }
+    let signedInAs;
+    try {
+        signedInAs = await io.callerPersonUid(token);
+    }
+    catch (err) {
+        return { status: "unavailable", ownerUid, reason: `could not confirm who is signed in (${message(err)})`, checkedAt };
+    }
+    if (signedInAs !== ownerUid)
+        return { status: "mismatch", ownerUid, signedInAs, checkedAt };
+    try {
+        const rows = await io.memberships(token);
+        const companies = rows
+            .filter((m) => m.status === "active")
+            .map((m) => ({ companyUid: m.companyUid, ...(m.companySlug ? { companySlug: m.companySlug } : {}), role: m.role }));
+        return { status: "ok", ownerUid, companies, checkedAt };
+    }
+    catch (err) {
+        return { status: "unavailable", ownerUid, reason: `could not read your owner's companies (${message(err)})`, checkedAt };
+    }
+}
+/** Successful lookups are reused for 5 minutes, failures retried after 1 minute. */
+export const OWNER_CONTEXT_TTL_MS = 5 * 60_000;
+export const OWNER_CONTEXT_RETRY_MS = 60_000;
+/** A turn never waits longer than this for a refresh; the lookup keeps going in the background. */
+export const OWNER_CONTEXT_WAIT_MS = 8_000;
+export class OwnerContextCache {
+    lookup;
+    nowMs;
+    waitMs;
+    ownerUid;
+    value = null;
+    at = 0;
+    pending = null;
+    constructor(lookup, nowMs = Date.now, waitMs = OWNER_CONTEXT_WAIT_MS, ownerUid = "") {
+        this.lookup = lookup;
+        this.nowMs = nowMs;
+        this.waitMs = waitMs;
+        this.ownerUid = ownerUid;
+    }
+    async get() {
+        const age = this.nowMs() - this.at;
+        if (this.value && age < (this.value.status === "ok" ? OWNER_CONTEXT_TTL_MS : OWNER_CONTEXT_RETRY_MS))
+            return this.value;
+        if (!this.pending) {
+            this.pending = this.lookup()
+                .then((v) => {
+                this.value = v;
+                this.at = this.nowMs();
+                return v;
+            })
+                .finally(() => {
+                this.pending = null;
+            });
+            this.pending.catch(() => undefined);
+        }
+        let timer;
+        const slow = new Promise((resolve) => {
+            timer = setTimeout(() => resolve(null), this.waitMs);
+        });
+        try {
+            const got = await Promise.race([this.pending, slow]);
+            if (got)
+                return got;
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+        // Slow refresh: the last answer (it carries its own checkedAt) beats none.
+        if (this.value)
+            return this.value;
+        return {
+            status: "unavailable",
+            ownerUid: this.ownerUid,
+            reason: "the check is taking too long",
+            checkedAt: new Date(this.nowMs()).toISOString(),
+        };
+    }
+}
+/**
+ * The block prepended to every owner DM turn. It names its subject explicitly so the
+ * model cannot confuse the owner's memberships with its own.
+ */
+export function ownerContextBlock(ctx, agentUid) {
+    const head = `[Owner context, checked ${ctx.checkedAt} by this bot's runtime with your owner's own HQ sign-in. It describes your OWNER (${ctx.ownerUid}), not you (${agentUid}).]`;
+    let body;
+    if (ctx.status === "ok") {
+        body =
+            ctx.companies.length === 0
+                ? "Your owner has no active company memberships. They work in a personal HQ."
+                : `Your owner's active companies:\n${ctx.companies
+                    .map((c) => `- ${c.companySlug ?? c.companyUid} (${c.companyUid}), role: ${c.role}`)
+                    .join("\n")}`;
+    }
+    else if (ctx.status === "mismatch") {
+        body =
+            `The HQ sign-in on this computer belongs to ${ctx.signedInAs}, not your owner, so your owner's companies could not be checked. ` +
+                "Do not say which companies your owner belongs to; tell them you could not check and why.";
+    }
+    else {
+        body =
+            `Your owner's companies could not be checked: ${ctx.reason}. ` +
+                "Do not guess and do not say they have no company; tell them you could not check right now.";
+    }
+    return `${head}\n${body}\n[End owner context]`;
+}
+//# sourceMappingURL=owner-context.js.map

package/dist/lib/bot/paths.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Local bot on-disk layout (local-bots US-003/US-005).
+ *
+ *   ~/.hq/bots/<name>/
+ *     bot.json            config (name, agt_ uid, owner, runtime, hqRoot)
+ *     memory/             the bot's memory when created with --memory local
+ *     machine-creds.json  0600 Cognito machine creds (never printed)
+ *     token-state/        per-bot machine token cache (HQ_MACHINE_TOKEN_STATE_DIR)
+ *     status.json         pid, state, restarts, last heartbeat
+ *     inbox-state.json    processed messageIds (idempotency across restarts)
+ *     session.json        model-CLI session id for resume (DM conversation)
+ *     session-room-<channelId>.json  one session per room the bot answers in
+ *     pid                 single-file pid lock
+ *     logs/bot.log        rotated at 5MB
+ *
+ * Injectable root (HQ_BOTS_ROOT) so tests never touch the real HOME.
+ */
+export declare const BOTS_DIRNAME = "bots";
+export declare const BOT_CONFIG_NAME = "bot.json";
+export declare const BOT_CREDS_NAME = "machine-creds.json";
+export declare const BOT_STATUS_NAME = "status.json";
+export declare const BOT_INBOX_STATE_NAME = "inbox-state.json";
+export declare const BOT_SESSION_NAME = "session.json";
+export declare const BOT_TOKEN_STATE_DIRNAME = "token-state";
+export declare const BOT_LOGS_DIRNAME = "logs";
+export declare const BOT_LOG_NAME = "bot.log";
+export declare const BOT_LOG_MAX_BYTES: number;
+export declare const LAUNCHD_LABEL_PREFIX = "ai.getindigo.hq-bot";
+export declare function isValidBotName(name: string): boolean;
+export declare function validateBotName(name: string): string;
+export declare function botsRoot(home?: string, env?: NodeJS.ProcessEnv): string;
+export declare function botDir(name: string, root?: string): string;
+export declare function botConfigPath(dir: string): string;
+export declare function botCredsPath(dir: string): string;
+export declare function botStatusPath(dir: string): string;
+export declare function botInboxStatePath(dir: string): string;
+/**
+ * Which model-CLI conversation an inbox item belongs to: the owner's DM thread
+ * ("dm") or one room ("room:<channelId>"). DM context stays private to the
+ * owner; each room gets its own coherent context.
+ */
+export type BotSessionScope = "dm" | `room:${string}`;
+export declare function roomSessionScope(channelId: string): BotSessionScope;
+export declare function botSessionPath(dir: string, scope?: BotSessionScope): string;
+export declare function botTokenStateDir(dir: string): string;
+/**
+ * Scratch working directory for model turns. Deliberately OUTSIDE the HQ git
+ * tree: Claude/Grok/Codex scan the working tree on every turn, and HQ's tree
+ * (tens of thousands of entries, a huge `git status`) cost ~20 s per reply on
+ * 2026-09-11. The system prompt tells the bot where HQ is; it `cd`s there when
+ * a request needs the files or `hq` commands.
+ */
+export declare function botTurnCwd(dir: string): string;
+/** ~/.hq/bots/<name>/memory — "local" memory, outside the synced HQ tree. */
+export declare function botLocalMemoryDir(dir: string): string;
+export declare function botLogsDir(dir: string): string;
+export declare function botLogPath(dir: string): string;
+export declare function launchdLabel(name: string): string;
+/** personal/workers/<name>/ relative to the HQ root. */
+export declare function botWorkerRelDir(name: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/lib/bot/paths.js

@@ -0,0 +1,103 @@
+/**
+ * Local bot on-disk layout (local-bots US-003/US-005).
+ *
+ *   ~/.hq/bots/<name>/
+ *     bot.json            config (name, agt_ uid, owner, runtime, hqRoot)
+ *     memory/             the bot's memory when created with --memory local
+ *     machine-creds.json  0600 Cognito machine creds (never printed)
+ *     token-state/        per-bot machine token cache (HQ_MACHINE_TOKEN_STATE_DIR)
+ *     status.json         pid, state, restarts, last heartbeat
+ *     inbox-state.json    processed messageIds (idempotency across restarts)
+ *     session.json        model-CLI session id for resume (DM conversation)
+ *     session-room-<channelId>.json  one session per room the bot answers in
+ *     pid                 single-file pid lock
+ *     logs/bot.log        rotated at 5MB
+ *
+ * Injectable root (HQ_BOTS_ROOT) so tests never touch the real HOME.
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+export const BOTS_DIRNAME = "bots";
+export const BOT_CONFIG_NAME = "bot.json";
+export const BOT_CREDS_NAME = "machine-creds.json";
+export const BOT_STATUS_NAME = "status.json";
+export const BOT_INBOX_STATE_NAME = "inbox-state.json";
+export const BOT_SESSION_NAME = "session.json";
+export const BOT_TOKEN_STATE_DIRNAME = "token-state";
+export const BOT_LOGS_DIRNAME = "logs";
+export const BOT_LOG_NAME = "bot.log";
+export const BOT_LOG_MAX_BYTES = 5 * 1024 * 1024;
+export const LAUNCHD_LABEL_PREFIX = "ai.getindigo.hq-bot";
+/** Lowercase slug: letters, digits, single hyphens; 1–40 chars. */
+const BOT_NAME_RE = /^[a-z0-9](?:[a-z0-9-]{0,38}[a-z0-9])?$/;
+export function isValidBotName(name) {
+    return BOT_NAME_RE.test(name) && !name.includes("--");
+}
+export function validateBotName(name) {
+    const trimmed = (name ?? "").trim();
+    if (!isValidBotName(trimmed)) {
+        throw Object.assign(new Error(`Invalid bot name "${name}": use 1–40 lowercase letters, digits, and single hyphens (e.g. "assistant", "scout-2").`), { expected: true });
+    }
+    return trimmed;
+}
+export function botsRoot(home = os.homedir(), env = process.env) {
+    const override = env.HQ_BOTS_ROOT?.trim();
+    if (override)
+        return override;
+    return path.join(home, ".hq", BOTS_DIRNAME);
+}
+export function botDir(name, root) {
+    return path.join(root ?? botsRoot(), name);
+}
+export function botConfigPath(dir) {
+    return path.join(dir, BOT_CONFIG_NAME);
+}
+export function botCredsPath(dir) {
+    return path.join(dir, BOT_CREDS_NAME);
+}
+export function botStatusPath(dir) {
+    return path.join(dir, BOT_STATUS_NAME);
+}
+export function botInboxStatePath(dir) {
+    return path.join(dir, BOT_INBOX_STATE_NAME);
+}
+export function roomSessionScope(channelId) {
+    return `room:${channelId}`;
+}
+export function botSessionPath(dir, scope = "dm") {
+    if (scope === "dm")
+        return path.join(dir, BOT_SESSION_NAME);
+    const channelId = scope.slice("room:".length).replace(/[^A-Za-z0-9_-]/g, "_");
+    return path.join(dir, `session-room-${channelId}.json`);
+}
+export function botTokenStateDir(dir) {
+    return path.join(dir, BOT_TOKEN_STATE_DIRNAME);
+}
+/**
+ * Scratch working directory for model turns. Deliberately OUTSIDE the HQ git
+ * tree: Claude/Grok/Codex scan the working tree on every turn, and HQ's tree
+ * (tens of thousands of entries, a huge `git status`) cost ~20 s per reply on
+ * 2026-09-11. The system prompt tells the bot where HQ is; it `cd`s there when
+ * a request needs the files or `hq` commands.
+ */
+export function botTurnCwd(dir) {
+    return path.join(dir, "cwd");
+}
+/** ~/.hq/bots/<name>/memory — "local" memory, outside the synced HQ tree. */
+export function botLocalMemoryDir(dir) {
+    return path.join(dir, "memory");
+}
+export function botLogsDir(dir) {
+    return path.join(dir, BOT_LOGS_DIRNAME);
+}
+export function botLogPath(dir) {
+    return path.join(dir, BOT_LOGS_DIRNAME, BOT_LOG_NAME);
+}
+export function launchdLabel(name) {
+    return `${LAUNCHD_LABEL_PREFIX}.${name}`;
+}
+/** personal/workers/<name>/ relative to the HQ root. */
+export function botWorkerRelDir(name) {
+    return path.join("personal", "workers", name);
+}
+//# sourceMappingURL=paths.js.map

package/dist/lib/bot/progress.d.ts

@@ -0,0 +1,84 @@
+/**
+ * In-between messages for one bot turn.
+ *
+ * While the model works, each finished assistant message ("I'll look up the
+ * page first.", "Found it — publishing now.") is posted to the same place the
+ * final reply goes, instead of being held back and glued into one reply at the
+ * end. Rules:
+ *
+ * - whole messages only (the runtime parsers never pass deltas, reasoning,
+ *   tool arguments or tool results); empty text is skipped
+ * - messages arriving close together are joined with a blank line into one
+ *   post, and posts are spaced at least `minGapMs` apart
+ * - if nothing has been said `workingNoticeMs` into the turn, ONE short
+ *   "working on it" note goes out
+ * - the final answer is posted only when it adds something: text already
+ *   posted (or about to be) is never repeated, including Grok's final result
+ *   that is just every message concatenated
+ *
+ * Posts are sent strictly in order. A failed post is logged by the caller's
+ * `send` and does not stop the turn.
+ */
+export declare const PROGRESS_COALESCE_MS = 2000;
+export declare const PROGRESS_MIN_GAP_MS = 4000;
+export declare const WORKING_NOTICE_MS = 60000;
+export declare const WORKING_NOTICE_TEXT = "Working on it \u2014 I'll reply here when it's done.";
+export interface ProgressPosterOptions {
+    /** Post one message; resolve true when it was delivered. */
+    send: (body: string) => Promise<boolean>;
+    now?: () => number;
+    setTimer?: (fn: () => void, ms: number) => unknown;
+    clearTimer?: (handle: unknown) => void;
+    coalesceMs?: number;
+    minGapMs?: number;
+    workingNoticeMs?: number;
+    workingNoticeText?: string;
+}
+/** Whitespace-insensitive form used to recognise repeated text. */
+export declare function normalizeForCompare(text: string): string;
+export declare class ProgressPoster {
+    private readonly send;
+    private readonly now;
+    private readonly setTimer;
+    private readonly clearTimer;
+    private readonly coalesceMs;
+    private readonly minGapMs;
+    private readonly workingNoticeMs;
+    private readonly workingNoticeText;
+    private pending;
+    /** Every message the model has said this turn (posted or pending), in order. */
+    private readonly said;
+    private flushTimer;
+    private noticeTimer;
+    private lastPostAt;
+    private chain;
+    private finished;
+    private noticeSent;
+    private delivered;
+    constructor(opts: ProgressPosterOptions);
+    /** Arm the one-time "working on it" note. Call when the turn starts. */
+    start(): void;
+    /** One finished assistant message from the model. */
+    message(text: string): void;
+    /** Posts that actually reached the chat (progress, notice and final). */
+    get postedCount(): number;
+    /** True once any message from the model was said this turn (not counting the notice). */
+    get saidAnything(): boolean;
+    /**
+     * The turn succeeded: post whatever is pending, then the final answer unless
+     * it repeats what was already said. Resolves once everything is sent.
+     */
+    finish(finalText: string): Promise<void>;
+    /**
+     * The turn failed: post what the model already said (it is real progress),
+     * then stop. The caller posts its own "did not finish" message afterwards.
+     */
+    abandon(): Promise<void>;
+    private repeatsSaid;
+    private scheduleFlush;
+    private flushNow;
+    private enqueue;
+    private cancelFlush;
+    private cancelNotice;
+}
+//# sourceMappingURL=progress.d.ts.map

package/dist/lib/bot/progress.js

@@ -0,0 +1,167 @@
+/**
+ * In-between messages for one bot turn.
+ *
+ * While the model works, each finished assistant message ("I'll look up the
+ * page first.", "Found it — publishing now.") is posted to the same place the
+ * final reply goes, instead of being held back and glued into one reply at the
+ * end. Rules:
+ *
+ * - whole messages only (the runtime parsers never pass deltas, reasoning,
+ *   tool arguments or tool results); empty text is skipped
+ * - messages arriving close together are joined with a blank line into one
+ *   post, and posts are spaced at least `minGapMs` apart
+ * - if nothing has been said `workingNoticeMs` into the turn, ONE short
+ *   "working on it" note goes out
+ * - the final answer is posted only when it adds something: text already
+ *   posted (or about to be) is never repeated, including Grok's final result
+ *   that is just every message concatenated
+ *
+ * Posts are sent strictly in order. A failed post is logged by the caller's
+ * `send` and does not stop the turn.
+ */
+export const PROGRESS_COALESCE_MS = 2_000;
+export const PROGRESS_MIN_GAP_MS = 4_000;
+export const WORKING_NOTICE_MS = 60_000;
+export const WORKING_NOTICE_TEXT = "Working on it — I'll reply here when it's done.";
+/** Whitespace-insensitive form used to recognise repeated text. */
+export function normalizeForCompare(text) {
+    return text.replace(/\s+/g, "");
+}
+export class ProgressPoster {
+    send;
+    now;
+    setTimer;
+    clearTimer;
+    coalesceMs;
+    minGapMs;
+    workingNoticeMs;
+    workingNoticeText;
+    pending = [];
+    /** Every message the model has said this turn (posted or pending), in order. */
+    said = [];
+    flushTimer = null;
+    noticeTimer = null;
+    lastPostAt = Number.NEGATIVE_INFINITY;
+    chain = Promise.resolve();
+    finished = false;
+    noticeSent = false;
+    delivered = 0;
+    constructor(opts) {
+        this.send = opts.send;
+        this.now = opts.now ?? Date.now;
+        this.setTimer = opts.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+        this.clearTimer = opts.clearTimer ?? ((h) => clearTimeout(h));
+        this.coalesceMs = opts.coalesceMs ?? PROGRESS_COALESCE_MS;
+        this.minGapMs = opts.minGapMs ?? PROGRESS_MIN_GAP_MS;
+        this.workingNoticeMs = opts.workingNoticeMs ?? WORKING_NOTICE_MS;
+        this.workingNoticeText = opts.workingNoticeText ?? WORKING_NOTICE_TEXT;
+    }
+    /** Arm the one-time "working on it" note. Call when the turn starts. */
+    start() {
+        if (this.finished || this.noticeTimer !== null || this.workingNoticeMs <= 0)
+            return;
+        this.noticeTimer = this.setTimer(() => {
+            this.noticeTimer = null;
+            if (this.finished || this.said.length > 0 || this.noticeSent)
+                return;
+            this.noticeSent = true;
+            this.enqueue(this.workingNoticeText);
+        }, this.workingNoticeMs);
+    }
+    /** One finished assistant message from the model. */
+    message(text) {
+        const t = text.trim();
+        if (this.finished || !t)
+            return;
+        this.cancelNotice();
+        this.said.push(t);
+        this.pending.push(t);
+        this.scheduleFlush();
+    }
+    /** Posts that actually reached the chat (progress, notice and final). */
+    get postedCount() {
+        return this.delivered;
+    }
+    /** True once any message from the model was said this turn (not counting the notice). */
+    get saidAnything() {
+        return this.said.length > 0;
+    }
+    /**
+     * The turn succeeded: post whatever is pending, then the final answer unless
+     * it repeats what was already said. Resolves once everything is sent.
+     */
+    async finish(finalText) {
+        if (this.finished)
+            return this.chain;
+        this.finished = true;
+        this.cancelNotice();
+        this.cancelFlush();
+        const final = finalText.trim();
+        if (final && !this.repeatsSaid(final))
+            this.pending.push(final);
+        if (this.pending.length === 0 && this.delivered === 0 && !final)
+            this.pending.push("(no reply)");
+        this.flushNow();
+        return this.chain;
+    }
+    /**
+     * The turn failed: post what the model already said (it is real progress),
+     * then stop. The caller posts its own "did not finish" message afterwards.
+     */
+    async abandon() {
+        if (this.finished)
+            return this.chain;
+        this.finished = true;
+        this.cancelNotice();
+        this.cancelFlush();
+        this.flushNow();
+        return this.chain;
+    }
+    repeatsSaid(final) {
+        const f = normalizeForCompare(final);
+        if (!f)
+            return true;
+        if (this.said.some((s) => normalizeForCompare(s) === f))
+            return true;
+        // Grok-style: the final result is every message joined, with or without separators.
+        return this.said.length > 1 && normalizeForCompare(this.said.join("")) === f;
+    }
+    scheduleFlush() {
+        this.cancelFlush();
+        const at = Math.max(this.now() + this.coalesceMs, this.lastPostAt + this.minGapMs);
+        this.flushTimer = this.setTimer(() => {
+            this.flushTimer = null;
+            this.flushNow();
+        }, Math.max(0, at - this.now()));
+    }
+    flushNow() {
+        if (this.pending.length === 0)
+            return;
+        const body = this.pending.join("\n\n");
+        this.pending = [];
+        this.enqueue(body);
+    }
+    enqueue(body) {
+        this.lastPostAt = this.now();
+        this.chain = this.chain.then(async () => {
+            try {
+                if (await this.send(body))
+                    this.delivered += 1;
+            }
+            catch {
+                /* the caller's send logs; a failed post never breaks the turn */
+            }
+        });
+    }
+    cancelFlush() {
+        if (this.flushTimer !== null)
+            this.clearTimer(this.flushTimer);
+        this.flushTimer = null;
+    }
+    cancelNotice() {
+        if (this.noticeTimer !== null)
+            this.clearTimer(this.noticeTimer);
+        this.noticeTimer = null;
+    }
+}
+//# sourceMappingURL=progress.js.map

package/dist/lib/bot/promote.d.ts

@@ -0,0 +1,16 @@
+import type { BotApi, BotPromotionState } from "./api.js";
+import type { BotConfig } from "./config.js";
+/** One recoverable local-to-cloud step, used by CLI and desktop. Never kills the
+ * local runtime, recopies provider login files, or changes another bot.
+ */
+export declare function promoteLocalBot(input: {
+    dir: string;
+    config: BotConfig;
+    companyUid: string;
+    api: BotApi;
+    drainTimeoutMs?: number;
+}): Promise<{
+    promotion: BotPromotionState;
+    pending: boolean;
+}>;
+//# sourceMappingURL=promote.d.ts.map