@indigoai-us/hq-cli 5.234.1 → 5.235.0

package/dist/lib/lanes/reconcile.js

@@ -632,14 +632,6 @@ export async function runPassBody(hqRoot, deps) {
     const livenessDeps = deps.livenessDeps ?? defaultLivenessDeps();
     let lanes;
     let questions;
-    if (!deps.dryRun) {
-        try {
-            await deps.syncTrackerQuestions?.(hqRoot);
-        }
-        catch (err) {
-            markError(summary, err);
-        }
-    }
     try {
         lanes = loadLaneRecords(hqRoot, summary);
         questions = loadQuestionRecords(hqRoot, summary);
@@ -843,14 +835,6 @@ export async function runPassBody(hqRoot, deps) {
         await admitQueued(hqRoot, drainLanes, summary, deps, now);
         await resumeAwaiting(hqRoot, drainLanes, freshQuestions, summary, deps);
     });
-    if (!deps.dryRun && deps.syncTrackerQuestions) {
-        try {
-            await deps.syncTrackerQuestions(hqRoot);
-        }
-        catch (err) {
-            markError(summary, err);
-        }
-    }
     if (!deps.dryRun && summary.errors.length === 0) {
         try {
             writeHeartbeatFile(hqRoot, summary, nowIso);

package/dist/lib/lanes/store.js

@@ -738,15 +738,7 @@ export function parseQuestionRecord(raw, filePath) {
             value: delivered_at,
         });
     }
-    const mesh_question_id = raw.mesh_question_id;
-    if (mesh_question_id !== undefined && (typeof mesh_question_id !== "string" || !mesh_question_id.trim())) {
-        throw new LaneSchemaError("mesh_question_id must be a non-empty string when present", { path: filePath, value: mesh_question_id });
-    }
-    const mesh_delivered_at = raw.mesh_delivered_at === undefined ? null : raw.mesh_delivered_at;
-    if (mesh_delivered_at !== null && (typeof mesh_delivered_at !== "string" || !Number.isFinite(Date.parse(mesh_delivered_at)))) {
-        throw new LaneSchemaError("mesh_delivered_at must be a valid timestamp or null", { path: filePath, value: mesh_delivered_at });
-    }
-    return { ...raw, delivered_at, mesh_delivered_at };
+    return { ...raw, delivered_at };
 }
 /**
  * HQ Sync sibling-twin grammar from `@indigoai-us/hq-cloud` `buildConflictPath`:

package/dist/lib/lanes/tracker-store.d.ts

@@ -22,17 +22,13 @@ export interface TrackerStore {
     read(kind: TrackerKind, id: string): StoreValue<TrackerRecord | null>;
     list(kind: TrackerKind): StoreValue<TrackerRecord[]>;
     create(record: TrackerRecordInput): StoreValue<TrackerRecord>;
-    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord, metadata?: {
-        approvalQuestionId?: string;
-    }): StoreValue<TrackerRecord>;
+    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord): StoreValue<TrackerRecord>;
 }
 export interface LocalTrackerStore extends TrackerStore {
     read(kind: TrackerKind, id: string): TrackerRecord | null;
     list(kind: TrackerKind): TrackerRecord[];
     create(record: TrackerRecordInput): TrackerRecord;
-    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord, metadata?: {
-        approvalQuestionId?: string;
-    }): TrackerRecord;
+    update(kind: TrackerKind, id: string, expectedVersion: number, change: (current: TrackerRecord) => TrackerRecord): TrackerRecord;
 }
 export declare function createLocalTrackerStore(projectDirectory: string, now?: () => Date): LocalTrackerStore;
 //# sourceMappingURL=tracker-store.d.ts.map

package/dist/lib/lanes/tracker-store.js

@@ -238,7 +238,7 @@ export function createLocalTrackerStore(projectDirectory, now = () => new Date()
             writeExclusive(path.join(directory, `${id}.json`), `${JSON.stringify(record, null, 2)}\n`);
             return record;
         },
-        update(kind, id, expectedVersion, change, _metadata) {
+        update(kind, id, expectedVersion, change) {
             const file = recordPath(root, kind, id);
             const directory = ensureKindDirectory(root, kind);
             return withRecordLock(file, () => {

package/dist/lib/lanes/types.d.ts

@@ -662,10 +662,6 @@ export interface QuestionRecord {
     version: number;
     /** Null until the owner starts a resume carrying this answer; absent on old records. */
     delivered_at?: string | null;
-    /** Work Mesh's server-issued id; absent for pre-TRK-9 local questions. */
-    mesh_question_id?: string;
-    /** Local checkpoint that the server accepted this question's delivery stamp. */
-    mesh_delivered_at?: string | null;
     body: QuestionBodyRef;
     routing_history: RoutingHistoryEntry[];
     answer?: QuestionAnswer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.234.1",
+  "version": "5.235.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {

package/dist/lib/flag-registry-worker-mode-cache.d.ts

@@ -1,20 +0,0 @@
-export declare const FLAG_REGISTRY_SELF_CONTAINED_WORKER_FLAG = "cli.flag-worker-self-contained";
-interface CachedWorkerMode {
-    version: number;
-    value: boolean;
-}
-export type FlagRegistryWorkerModeCacheOperation = "read" | "write";
-export type FlagRegistryWorkerModeCacheStep = "mkdir" | "write_temp" | "link" | "unlink" | "prune" | "readdir" | "read";
-/** Build bounded filesystem diagnostics without exposing the state directory. */
-export declare function flagRegistryWorkerModeCacheFailureContext(error: unknown, operation: FlagRegistryWorkerModeCacheOperation, filePath: string, env?: NodeJS.ProcessEnv): {
-    exception: unknown;
-    tags: Record<string, string>;
-};
-/** Keep the last server snapshot decision for this one startup-mode flag. */
-export declare function flagRegistryWorkerModeCachePath(stateDir: string, scopeIdentifiers: readonly string[]): string;
-/** A missing, invalid, or inaccessible cache never enables the rollout. */
-export declare function readCachedFlagRegistryWorkerMode(filePath: string): CachedWorkerMode | null;
-export declare function writeCachedFlagRegistryWorkerMode(filePath: string, snapshot: CachedWorkerMode): void;
-export declare function flagRegistryStateDir(env?: NodeJS.ProcessEnv): string;
-export {};
-//# sourceMappingURL=flag-registry-worker-mode-cache.d.ts.map

package/dist/lib/flag-registry-worker-mode-cache.js

@@ -1,254 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { createHash, randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-export const FLAG_REGISTRY_SELF_CONTAINED_WORKER_FLAG = "cli.flag-worker-self-contained";
-class FlagRegistryWorkerModeCacheStepError extends Error {
-    cacheStep;
-    originalError;
-    constructor(cacheStep, originalError) {
-        super(`Flag registry worker-mode cache failed at ${cacheStep}`);
-        this.cacheStep = cacheStep;
-        this.originalError = originalError;
-        this.name = "FlagRegistryWorkerModeCacheStepError";
-    }
-}
-const KNOWN_ERRNOS = new Set([
-    "EACCES",
-    "EBUSY",
-    "EEXIST",
-    "EIO",
-    "EISDIR",
-    "EMFILE",
-    "ENFILE",
-    "ENOENT",
-    "ENOSPC",
-    "ENOTDIR",
-    "EPERM",
-    "EROFS",
-]);
-function withCacheFsStep(cacheStep, operation) {
-    try {
-        return operation();
-    }
-    catch (error) {
-        if (error instanceof FlagRegistryWorkerModeCacheStepError)
-            throw error;
-        throw new FlagRegistryWorkerModeCacheStepError(cacheStep, error);
-    }
-}
-function originalCacheError(error) {
-    return error instanceof FlagRegistryWorkerModeCacheStepError
-        ? error.originalError
-        : error;
-}
-function cacheErrorCode(error) {
-    const original = originalCacheError(error);
-    return typeof original === "object" && original !== null && "code" in original
-        ? original.code
-        : undefined;
-}
-function directoryHasUchg(directory) {
-    if (process.platform !== "darwin")
-        return "unknown";
-    try {
-        const rawFlags = execFileSync("/usr/bin/stat", ["-f", "%f", directory], { timeout: 1000 }).toString("utf8").trim();
-        if (!/^\d+$/.test(rawFlags))
-            return "unknown";
-        const flags = Number(rawFlags);
-        if (!Number.isSafeInteger(flags))
-            return "unknown";
-        return String((flags & 0x00000002) !== 0 || (flags & 0x00020000) !== 0);
-    }
-    catch {
-        // This bounded diagnostic is best-effort; preserve unknown and the original cache error.
-        return "unknown";
-    }
-}
-/** Build bounded filesystem diagnostics without exposing the state directory. */
-export function flagRegistryWorkerModeCacheFailureContext(error, operation, filePath, env = process.env) {
-    const cacheError = error instanceof FlagRegistryWorkerModeCacheStepError
-        ? error
-        : undefined;
-    const directory = path.dirname(filePath);
-    let dirExists = "unknown";
-    let stats;
-    try {
-        stats = fs.statSync(directory);
-        dirExists = "true";
-    }
-    catch (metadataError) {
-        if (cacheErrorCode(metadataError) === "ENOENT")
-            dirExists = "false";
-        // Keep inaccessible metadata unknown; diagnostics must not hide the cache error.
-    }
-    const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
-    const ownerMatches = typeof uid === "number" && typeof stats?.uid === "number"
-        ? String(stats.uid === uid)
-        : "unknown";
-    const dirMode = typeof stats?.mode === "number"
-        ? (stats.mode & 0o777).toString(8).padStart(3, "0")
-        : "unknown";
-    const dirHasUchg = directoryHasUchg(directory);
-    const rawErrno = cacheErrorCode(error);
-    const errno = typeof rawErrno === "string" && KNOWN_ERRNOS.has(rawErrno)
-        ? rawErrno
-        : "UNKNOWN";
-    const stateDirSource = env.HQ_STATE_DIR?.trim() ? "env" : "home";
-    return {
-        exception: originalCacheError(error),
-        tags: {
-            cache_op: operation,
-            cache_step: cacheError?.cacheStep ?? (operation === "read" ? "read" : "write_temp"),
-            errno,
-            state_dir_source: stateDirSource,
-            dir_exists: dirExists,
-            dir_owner_matches_uid: ownerMatches,
-            dir_mode: dirMode,
-            dir_has_uchg: dirHasUchg,
-            cache_path_kind: "<stateDir>/flags/<basename>",
-        },
-    };
-}
-/** Keep the last server snapshot decision for this one startup-mode flag. */
-export function flagRegistryWorkerModeCachePath(stateDir, scopeIdentifiers) {
-    const basename = scopeIdentifiers.length === 0
-        ? "worker-mode-default.json"
-        : `worker-mode-${createHash("sha256")
-            .update([...scopeIdentifiers].sort().join("\0"))
-            .digest("hex")
-            .slice(0, 24)}.json`;
-    return path.join(stateDir, "flags", basename);
-}
-/** A missing, invalid, or inaccessible cache never enables the rollout. */
-export function readCachedFlagRegistryWorkerMode(filePath) {
-    let latest = readCacheRecordIfPresent(filePath);
-    const directory = path.dirname(filePath);
-    if (!withCacheFsStep("read", () => fs.existsSync(directory)))
-        return latest;
-    const basename = path.basename(filePath);
-    const versionedPrefix = `${basename}.v`;
-    for (const entry of withCacheFsStep("readdir", () => fs.readdirSync(directory))) {
-        if (!entry.startsWith(versionedPrefix) || !entry.endsWith(".json"))
-            continue;
-        const versionedPath = path.join(directory, entry);
-        const record = readCacheRecordIfPresent(versionedPath);
-        if (record)
-            latest = newerCacheRecord(latest, record);
-    }
-    return latest;
-}
-export function writeCachedFlagRegistryWorkerMode(filePath, snapshot) {
-    withCacheFsStep("mkdir", () => fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 }));
-    const existing = readCachedFlagRegistryWorkerMode(filePath);
-    if (existing && snapshot.version < existing.version)
-        return;
-    // Each registry version gets its own immutable destination. Concurrent
-    // processes can publish v7 and v8 in either order without an older value
-    // replacing the newer record.
-    const versionedPath = `${filePath}.v${snapshot.version}.json`;
-    const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
-    try {
-        withCacheFsStep("write_temp", () => fs.writeFileSync(tempPath, `${JSON.stringify(snapshot)}\n`, {
-            encoding: "utf8",
-            mode: 0o600,
-            flag: "wx",
-        }));
-        try {
-            withCacheFsStep("link", () => fs.linkSync(tempPath, versionedPath));
-        }
-        catch (error) {
-            if (!isAlreadyExistsError(error))
-                throw error;
-            const existingVersion = readCacheRecord(versionedPath);
-            if (existingVersion.value !== snapshot.value) {
-                throw new FlagRegistryWorkerModeCacheStepError("link", new Error("Conflicting flag-registry worker cache values share a version"));
-            }
-        }
-    }
-    finally {
-        if (withCacheFsStep("unlink", () => fs.existsSync(tempPath))) {
-            withCacheFsStep("unlink", () => fs.unlinkSync(tempPath));
-        }
-    }
-    pruneOlderCacheRecords(filePath);
-}
-export function flagRegistryStateDir(env = process.env) {
-    const override = env.HQ_STATE_DIR?.trim();
-    return override ? override : path.join(os.homedir(), ".hq");
-}
-function isCachedWorkerMode(value) {
-    return typeof value === "object" && value !== null &&
-        "version" in value && typeof value.version === "number" &&
-        Number.isSafeInteger(value.version) && value.version >= 0 &&
-        "value" in value && typeof value.value === "boolean";
-}
-function readCacheRecord(filePath) {
-    const contents = withCacheFsStep("read", () => fs.readFileSync(filePath, "utf8"));
-    const value = JSON.parse(contents);
-    if (!isCachedWorkerMode(value)) {
-        throw new Error("Cached flag-registry worker mode has an invalid shape");
-    }
-    return value;
-}
-function newerCacheRecord(current, candidate) {
-    if (!current || candidate.version > current.version)
-        return candidate;
-    if (candidate.version === current.version && candidate.value !== current.value) {
-        throw new Error("Conflicting flag-registry worker cache values share a version");
-    }
-    return current;
-}
-function pruneOlderCacheRecords(filePath) {
-    const latest = readCachedFlagRegistryWorkerMode(filePath);
-    if (!latest)
-        return;
-    const directory = path.dirname(filePath);
-    const basename = path.basename(filePath);
-    const versionedPrefix = `${basename}.v`;
-    for (const entry of withCacheFsStep("readdir", () => fs.readdirSync(directory))) {
-        if (!entry.startsWith(versionedPrefix) || !entry.endsWith(".json"))
-            continue;
-        const recordPath = path.join(directory, entry);
-        const record = readCacheRecordIfPresent(recordPath);
-        if (record && record.version < latest.version) {
-            try {
-                withCacheFsStep("prune", () => fs.unlinkSync(recordPath));
-            }
-            catch (error) {
-                if (!isNotFoundError(error))
-                    throw error;
-            }
-        }
-    }
-    if (withCacheFsStep("prune", () => fs.existsSync(filePath))) {
-        const legacyRecord = readCacheRecordIfPresent(filePath);
-        if (legacyRecord && legacyRecord.version < latest.version) {
-            try {
-                withCacheFsStep("prune", () => fs.unlinkSync(filePath));
-            }
-            catch (error) {
-                if (!isNotFoundError(error))
-                    throw error;
-            }
-        }
-    }
-}
-function readCacheRecordIfPresent(filePath) {
-    try {
-        return readCacheRecord(filePath);
-    }
-    catch (error) {
-        if (isNotFoundError(error))
-            return null;
-        throw error;
-    }
-}
-function isAlreadyExistsError(error) {
-    return cacheErrorCode(error) === "EEXIST";
-}
-function isNotFoundError(error) {
-    return cacheErrorCode(error) === "ENOENT";
-}
-//# sourceMappingURL=flag-registry-worker-mode-cache.js.map

package/dist/lib/lanes/tracker-mesh-questions.d.ts

@@ -1,54 +0,0 @@
-import type { LaneCompanyRef, QuestionRecord } from "./types.js";
-import { type TrackerMeshRequest } from "./tracker-mesh.js";
-export type TrackerMeshQuestionAudience = "owner" | "operator" | "lane";
-export type TrackerMeshQuestionStatus = "pending" | "answered" | "cancelled";
-export interface TrackerMeshQuestionRow {
-    questionId: string;
-    threadId: string;
-    companyUid: string;
-    projectId: string;
-    laneId: string;
-    host: {
-        kind: string;
-        id: string;
-    };
-    audience: TrackerMeshQuestionAudience;
-    audienceChain: string[];
-    routingHistory: Array<Record<string, string>>;
-    question: string;
-    context?: string;
-    options: string[];
-    recommended?: string;
-    askedAt: string;
-    status: TrackerMeshQuestionStatus;
-    choice?: string;
-    notes?: string;
-    answeredBy?: string;
-    answeredAt?: string;
-    deliveredAt?: string;
-}
-export interface TrackerMeshQuestionInput {
-    laneId: string;
-    threadId?: string;
-    projectId: string;
-    audience: TrackerMeshQuestionAudience;
-    audienceChain: string[];
-    routingHistory: Array<Record<string, string>>;
-    question: string;
-    context: string;
-    options: string[];
-    recommended?: string;
-}
-export interface TrackerMeshQuestionClient {
-    create(input: TrackerMeshQuestionInput): Promise<TrackerMeshQuestionRow>;
-    list(statuses?: readonly TrackerMeshQuestionStatus[]): Promise<TrackerMeshQuestionRow[]>;
-    answer(questionId: string, choice: string, notes?: string): Promise<TrackerMeshQuestionRow>;
-    delivered(questionId: string): Promise<TrackerMeshQuestionRow>;
-}
-/** Persist a local delivery checkpoint only after the Work Mesh stamp succeeds. */
-export declare function deliverTrackerMeshQuestionOnce(question: QuestionRecord, company: LaneCompanyRef, client: Pick<TrackerMeshQuestionClient, "delivered">, persist: (deliveredAt: string) => QuestionRecord): Promise<QuestionRecord>;
-export declare function createTrackerMeshQuestionClient(options: {
-    company: LaneCompanyRef;
-    request?: TrackerMeshRequest;
-}): TrackerMeshQuestionClient;
-//# sourceMappingURL=tracker-mesh-questions.d.ts.map

package/dist/lib/lanes/tracker-mesh-questions.js

@@ -1,138 +0,0 @@
-import { meshJson, requireToken } from "../mesh/client.js";
-import { LanesError } from "./errors.js";
-import { mapWorkMeshTrackerError } from "./tracker-mesh.js";
-/** Persist a local delivery checkpoint only after the Work Mesh stamp succeeds. */
-export async function deliverTrackerMeshQuestionOnce(question, company, client, persist) {
-    if (!question.mesh_question_id || question.status !== "answered" ||
-        !question.delivered_at || question.mesh_delivered_at)
-        return question;
-    const delivered = await client.delivered(question.mesh_question_id);
-    if (delivered.questionId !== question.mesh_question_id ||
-        delivered.companyUid !== company.uid ||
-        delivered.laneId !== question.lane_id ||
-        delivered.projectId !== question.project_id ||
-        !delivered.deliveredAt) {
-        throw new LanesError("tracker_mesh_response_invalid", "Work Mesh did not stamp the expected question as delivered", {
-            mesh_question_id: question.mesh_question_id,
-            question_id: question.question_id,
-        });
-    }
-    return persist(delivered.deliveredAt);
-}
-const ROOT = "/v1/work-mesh/tracker/questions";
-const AUDIENCES = ["owner", "operator", "lane"];
-const STATUSES = ["pending", "answered", "cancelled"];
-const MAX_PAGES_PER_FILTER = 10;
-function invalidResponse(field) {
-    throw new LanesError("tracker_mesh_response_invalid", `Work Mesh returned an invalid tracker question ${field}`, { field });
-}
-function parseQuestion(raw, company) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return invalidResponse("row");
-    const row = raw;
-    if (typeof row.questionId !== "string" || !row.questionId ||
-        typeof row.threadId !== "string" || !row.threadId ||
-        row.companyUid !== company.uid ||
-        typeof row.projectId !== "string" || !row.projectId ||
-        typeof row.laneId !== "string" || !row.laneId ||
-        !AUDIENCES.includes(row.audience) ||
-        !STATUSES.includes(row.status) ||
-        typeof row.question !== "string" ||
-        !Array.isArray(row.options) || row.options.some((entry) => typeof entry !== "string") ||
-        !Array.isArray(row.audienceChain) || row.audienceChain.some((entry) => typeof entry !== "string") ||
-        !Array.isArray(row.routingHistory) ||
-        typeof row.askedAt !== "string" || !Number.isFinite(Date.parse(row.askedAt)))
-        return invalidResponse("row");
-    if (row.context !== undefined && typeof row.context !== "string")
-        return invalidResponse("context");
-    if (row.recommended !== undefined && typeof row.recommended !== "string")
-        return invalidResponse("recommended");
-    if (row.choice !== undefined && typeof row.choice !== "string")
-        return invalidResponse("choice");
-    if (row.notes !== undefined && typeof row.notes !== "string")
-        return invalidResponse("notes");
-    if (row.answeredBy !== undefined && typeof row.answeredBy !== "string")
-        return invalidResponse("answeredBy");
-    if (row.answeredAt !== undefined && (typeof row.answeredAt !== "string" || !Number.isFinite(Date.parse(row.answeredAt))))
-        return invalidResponse("answeredAt");
-    if (row.deliveredAt !== undefined && (typeof row.deliveredAt !== "string" || !Number.isFinite(Date.parse(row.deliveredAt))))
-        return invalidResponse("deliveredAt");
-    if (!row.host || typeof row.host !== "object" || Array.isArray(row.host) || typeof row.host.kind !== "string" || typeof row.host.id !== "string")
-        return invalidResponse("host");
-    return row;
-}
-export function createTrackerMeshQuestionClient(options) {
-    const { company } = options;
-    if (!company.slug.trim() || !company.uid.trim()) {
-        throw new LanesError("tracker_company_unresolved", "A resolved company slug and uid are required for Work Mesh tracker questions", {});
-    }
-    const request = options.request ?? (async (endpoint, init) => {
-        const token = await requireToken({ interactive: false });
-        return meshJson(token, endpoint, init);
-    });
-    const call = async (endpoint, init) => {
-        try {
-            const result = await request(endpoint, init);
-            if (!result || typeof result !== "object" || Array.isArray(result))
-                return invalidResponse("response");
-            return result;
-        }
-        catch (err) {
-            throw mapWorkMeshTrackerError(err);
-        }
-    };
-    return {
-        async create(input) {
-            const result = await call(ROOT, { method: "POST", body: { companyUid: company.uid, ...input } });
-            return parseQuestion(result.question, company);
-        },
-        async list(requestedStatuses = STATUSES) {
-            const uniqueStatuses = [...new Set(requestedStatuses)];
-            if (uniqueStatuses.some((status) => !STATUSES.includes(status))) {
-                throw new LanesError("tracker_mesh_query_invalid", "Unsupported Work Mesh tracker question status filter", { statuses: uniqueStatuses });
-            }
-            const rows = new Map();
-            for (const audience of AUDIENCES) {
-                for (const status of uniqueStatuses) {
-                    let cursor;
-                    for (let page = 0; page < MAX_PAGES_PER_FILTER; page += 1) {
-                        const query = { companyUid: company.uid, audience, status, limit: "100", ...(cursor ? { cursor } : {}) };
-                        const result = await call(ROOT, { method: "GET", query });
-                        if (!Array.isArray(result.questions))
-                            return invalidResponse("questions list");
-                        for (const raw of result.questions) {
-                            const row = parseQuestion(raw, company);
-                            if (row.audience !== audience || row.status !== status)
-                                return invalidResponse("filter scope");
-                            rows.set(row.questionId, row);
-                        }
-                        if (result.nextCursor === undefined)
-                            break;
-                        if (typeof result.nextCursor !== "string" || !result.nextCursor || result.nextCursor === cursor)
-                            return invalidResponse("cursor");
-                        if (page === MAX_PAGES_PER_FILTER - 1) {
-                            throw new LanesError("tracker_mesh_response_incomplete", "Work Mesh tracker question list exceeded its bounded page limit", { audience, status, max_pages: MAX_PAGES_PER_FILTER });
-                        }
-                        cursor = result.nextCursor;
-                    }
-                }
-            }
-            return [...rows.values()].sort((a, b) => b.askedAt.localeCompare(a.askedAt) || a.questionId.localeCompare(b.questionId));
-        },
-        async answer(questionId, choice, notes) {
-            const result = await call(`${ROOT}/${encodeURIComponent(questionId)}/answer`, {
-                method: "POST",
-                body: { companyUid: company.uid, choice, ...(notes === undefined ? {} : { notes }) },
-            });
-            return parseQuestion(result.question, company);
-        },
-        async delivered(questionId) {
-            const result = await call(`${ROOT}/${encodeURIComponent(questionId)}/delivered`, {
-                method: "POST",
-                body: { companyUid: company.uid },
-            });
-            return parseQuestion(result.question, company);
-        },
-    };
-}
-//# sourceMappingURL=tracker-mesh-questions.js.map

package/dist/lib/lanes/tracker-mesh.d.ts

@@ -1,19 +0,0 @@
-import { LanesError } from "./errors.js";
-import type { LaneCompanyRef } from "./types.js";
-import type { TrackerStore } from "./tracker-store.js";
-export interface TrackerMeshRequestInit {
-    method?: string;
-    body?: Record<string, unknown>;
-    query?: Record<string, string>;
-}
-export type TrackerMeshRequest = (path: string, init: TrackerMeshRequestInit) => Promise<unknown>;
-export interface WorkMeshTrackerStoreOptions {
-    company: LaneCompanyRef;
-    projectId: string;
-    request?: TrackerMeshRequest;
-    now?: () => Date;
-    clientRecordId?: () => string;
-}
-export declare function mapWorkMeshTrackerError(err: unknown): LanesError;
-export declare function createWorkMeshTrackerStore(options: WorkMeshTrackerStoreOptions): TrackerStore;
-//# sourceMappingURL=tracker-mesh.d.ts.map