@lightward/mechanic-cli 0.1.0

package/dist/tasks.js

@@ -0,0 +1,546 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { CliError } from "./errors.js";
+import { ensureDir, pathExists, readJson, readText, removeFile, writeJson, writeText } from "./fs.js";
+import { stableStringify } from "./json.js";
+const SPLIT_FILES = [
+    ["script", "script.liquid"],
+    ["docs", "docs.md"],
+    ["subscriptions_template", "subscriptions.liquid"],
+    ["online_store_javascript", "online_store_javascript.js.liquid"],
+    ["order_status_javascript", "order_status_javascript.js.liquid"],
+];
+const REMOTE_TASK_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function taskSlug(input) {
+    const slug = input
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return slug || "task";
+}
+export async function taskFiles(project) {
+    if (!(await pathExists(project.tasksDir))) {
+        return [];
+    }
+    const entries = await fs.readdir(project.tasksDir, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+        .map((entry) => path.join(project.tasksDir, entry.name))
+        .sort();
+}
+export function slugFromTaskFile(filePath) {
+    return taskSlug(path.basename(filePath, ".json"));
+}
+export function taskPath(project, slug) {
+    return path.join(project.tasksDir, `${slug}.json`);
+}
+function displayPath(filePath) {
+    return filePath.replace(/\\/g, "/");
+}
+export function displayTaskPath(project, filePath) {
+    const absolutePath = path.resolve(filePath);
+    const absoluteTasksDir = path.resolve(project.tasksDir);
+    const relativeToTasksDir = path.relative(absoluteTasksDir, absolutePath);
+    if (relativeToTasksDir && !relativeToTasksDir.startsWith("..") && !path.isAbsolute(relativeToTasksDir)) {
+        return displayPath(path.join(project.tasksDirName, relativeToTasksDir));
+    }
+    const segments = absolutePath.split(path.sep);
+    const tasksSegmentIndex = segments.lastIndexOf(path.basename(project.tasksDirName));
+    if (tasksSegmentIndex >= 0 && tasksSegmentIndex < segments.length - 1) {
+        return displayPath(segments.slice(tasksSegmentIndex).join(path.sep));
+    }
+    return displayPath(path.relative(project.cwd, absolutePath));
+}
+function duplicateTaskSlugMessages(project, files) {
+    const filesBySlug = new Map();
+    for (const file of files) {
+        const slug = slugFromTaskFile(file);
+        filesBySlug.set(slug, [...(filesBySlug.get(slug) || []), displayTaskPath(project, file)]);
+    }
+    return [...filesBySlug.entries()].flatMap(([slug, slugFiles]) => {
+        if (slugFiles.length < 2) {
+            return [];
+        }
+        return [`- ${slug}: ${slugFiles.join(", ")}`];
+    });
+}
+export async function readTaskFile(filePath) {
+    return stripTaskIds(await readRawTaskFile(filePath));
+}
+export async function readRawTaskFile(filePath) {
+    const task = await readJson(filePath);
+    if (!task || typeof task !== "object" || Array.isArray(task)) {
+        throw new CliError(`${filePath} must contain a JSON object`);
+    }
+    return task;
+}
+function hasSubscriptionsTemplate(task) {
+    return task.subscriptions_template !== undefined && task.subscriptions_template !== null;
+}
+function stripTaskIds(task) {
+    const { id: _id, remote_id: _remoteId, ...exportTask } = task;
+    return exportTask;
+}
+function stripGeneratedFields(task) {
+    const exportTask = { ...task };
+    if (hasSubscriptionsTemplate(exportTask)) {
+        delete exportTask.subscriptions;
+    }
+    return exportTask;
+}
+function stripHelperMetadata(task) {
+    const { _mechanic: _helperMetadata, ...exportTask } = task;
+    return exportTask;
+}
+export async function writeTaskFilePath(filePath, task) {
+    await writeJson(filePath, stripGeneratedFields(stripTaskIds(task)));
+    return filePath;
+}
+export async function refreshHelperDirForTaskFile(filePath) {
+    const helperDir = helperDirForTaskFile(filePath);
+    if (helperDir && await pathExists(path.join(helperDir, "task.json"))) {
+        await unbundleTask(filePath, helperDir);
+    }
+}
+export async function writeTaskFilePathAndRefreshHelper(filePath, task) {
+    await writeTaskFilePath(filePath, task);
+    await refreshHelperDirForTaskFile(filePath);
+    return filePath;
+}
+export async function writeTaskFile(project, slug, task, force = false) {
+    const filePath = taskPath(project, slug);
+    if (!force && await pathExists(filePath)) {
+        throw new CliError(`${displayTaskPath(project, filePath)} already exists. Re-run with --force to overwrite.`);
+    }
+    return writeTaskFilePathAndRefreshHelper(filePath, task);
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+function looksLikeTaskPath(input) {
+    return input.endsWith(".json") || input.includes("/") || input.includes(path.sep);
+}
+function selectorSlug(input) {
+    const normalized = input.toLowerCase().endsWith(".json") ? input.slice(0, -".json".length) : input;
+    return taskSlug(path.basename(normalized));
+}
+async function statIfExists(filePath) {
+    try {
+        return await fs.stat(filePath);
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+function linkForResolvedSlug(project, slug) {
+    return project.links.tasks[slug] || null;
+}
+function linkedTaskFile(project, slug, link) {
+    return path.resolve(project.cwd, link.file || `${project.tasksDirName}/${slug}.json`);
+}
+function selectorFromFile(project, input, file, source) {
+    const slug = slugFromTaskFile(file);
+    const link = linkForResolvedSlug(project, slug);
+    return {
+        input,
+        source,
+        slug,
+        file,
+        link,
+        remoteId: link?.remote_id,
+    };
+}
+function selectorFromHelper(project, input, helperDir) {
+    const slug = taskSlug(path.basename(helperDir));
+    const link = linkForResolvedSlug(project, slug);
+    return {
+        input,
+        source: "helper",
+        slug,
+        file: `${helperDir}.json`,
+        helperDir,
+        link,
+        remoteId: link?.remote_id,
+    };
+}
+function selectorFromLink(project, input, slug, link, source) {
+    return {
+        input,
+        source,
+        slug,
+        file: linkedTaskFile(project, slug, link),
+        link,
+        remoteId: link.remote_id,
+    };
+}
+function linkForRemoteId(project, remoteId) {
+    return Object.entries(project.links.tasks).find(([, link]) => link.remote_id === remoteId) || null;
+}
+function pathCandidatesForSelector(project, input) {
+    const raw = path.resolve(project.cwd, input);
+    const candidates = [raw];
+    if (!input.toLowerCase().endsWith(".json")) {
+        candidates.push(`${raw}.json`);
+    }
+    if (!looksLikeTaskPath(input)) {
+        const slug = selectorSlug(input);
+        candidates.push(path.join(project.tasksDir, slug));
+        candidates.push(taskPath(project, slug));
+    }
+    return uniqueStrings(candidates);
+}
+async function resolveExistingPathSelector(project, input, allowHelperDir) {
+    for (const candidate of pathCandidatesForSelector(project, input)) {
+        const stat = await statIfExists(candidate);
+        if (!stat) {
+            continue;
+        }
+        if (stat.isFile()) {
+            return selectorFromFile(project, input, candidate, "file");
+        }
+        if (!stat.isDirectory()) {
+            continue;
+        }
+        if (!(await pathExists(path.join(candidate, "task.json")))) {
+            throw new CliError(`${displayTaskPath(project, candidate)} is a directory, not a Mechanic helper task directory.`);
+        }
+        if (allowHelperDir) {
+            return selectorFromHelper(project, input, candidate);
+        }
+        const siblingFile = `${candidate}.json`;
+        if (await pathExists(siblingFile)) {
+            return selectorFromFile(project, input, siblingFile, "helper");
+        }
+        throw new CliError([
+            `No canonical task JSON file found for helper directory ${displayTaskPath(project, candidate)}.`,
+            `Run "mechanic tasks bundle ${displayTaskPath(project, candidate)}" first.`,
+        ].join("\n"), 2);
+    }
+    return null;
+}
+function ambiguousTaskSelectorError(project, input, files) {
+    return new CliError([
+        `More than one local task matched "${input}".`,
+        ...files.map((file) => `  ${displayTaskPath(project, file)}`),
+        "",
+        "Use the full file path.",
+    ].join("\n"), 2);
+}
+async function resolveLocalSlugSelector(project, input) {
+    const slug = selectorSlug(input);
+    const files = (await taskFiles(project)).filter((file) => slugFromTaskFile(file) === slug);
+    if (files.length > 1) {
+        throw ambiguousTaskSelectorError(project, input, files);
+    }
+    if (files.length === 1) {
+        return selectorFromFile(project, input, files[0], "slug");
+    }
+    const link = linkForResolvedSlug(project, slug);
+    if (link) {
+        return selectorFromLink(project, input, slug, link, "slug");
+    }
+    return null;
+}
+export async function resolveTaskSelector(project, input, options = {}) {
+    const local = await resolveExistingPathSelector(project, input, Boolean(options.allowHelperDir));
+    if (local) {
+        return local;
+    }
+    const remoteLink = linkForRemoteId(project, input);
+    if (remoteLink) {
+        return selectorFromLink(project, input, remoteLink[0], remoteLink[1], "linked_remote_id");
+    }
+    const slug = await resolveLocalSlugSelector(project, input);
+    if (slug) {
+        return slug;
+    }
+    if (options.allowRemoteId && REMOTE_TASK_ID_PATTERN.test(input)) {
+        return {
+            input,
+            source: "remote_id",
+            remoteId: input,
+        };
+    }
+    if (REMOTE_TASK_ID_PATTERN.test(input)) {
+        throw new CliError([
+            `No local task file is linked to task ID ${input}.`,
+            `Run "mechanic tasks pull ${input}" first, or use "mechanic tasks preview --remote ${input}" to preview the current task in Mechanic.`,
+        ].join("\n"), 2);
+    }
+    if (looksLikeTaskPath(input)) {
+        throw new CliError(`No local task file or helper directory found: ${input}`, 2);
+    }
+    throw new CliError(`No local task matched "${input}". Use a task file path or run "mechanic tasks pull" first.`, 2);
+}
+export async function selectedTaskFiles(project, input, all) {
+    if (input && all) {
+        throw new CliError("Use either a file argument or --all, not both.");
+    }
+    if (all) {
+        const files = await taskFiles(project);
+        if (files.length === 0) {
+            throw new CliError(`No task JSON files found in ${project.tasksDirName}`);
+        }
+        const duplicates = duplicateTaskSlugMessages(project, files);
+        if (duplicates.length > 0) {
+            throw new CliError([
+                "Multiple task files normalize to the same task slug.",
+                ...duplicates,
+                "Rename one of the files before continuing.",
+            ].join("\n"), 2);
+        }
+        return files;
+    }
+    if (!input) {
+        throw new CliError("A task file argument or --all is required.");
+    }
+    let selector;
+    try {
+        selector = await resolveTaskSelector(project, input);
+    }
+    catch (error) {
+        if (looksLikeTaskPath(input)
+            && error instanceof CliError
+            && error.message.startsWith("No local task file or helper directory found:")) {
+            return [path.resolve(project.cwd, input)];
+        }
+        throw error;
+    }
+    if (!selector.file) {
+        throw new CliError(`No local task file found for ${input}.`, 2);
+    }
+    return [selector.file];
+}
+export function remoteChangedSinceLastPull(link, remote) {
+    return remote.content_hash !== link.last_remote_content_hash;
+}
+export function remoteChangedSinceLastPullDetails(force = false) {
+    return force ? "remote changed since last pull; --force set" : "remote changed since last pull";
+}
+export function remoteChangedSinceLastPullMessage(relativeFile, remoteId) {
+    return `${relativeFile} has remote changes since the last pull. Run "mechanic tasks diff ${relativeFile}" to review, then "mechanic tasks pull ${remoteId}" to keep the remote version, or re-run with --force only if the local file should win.`;
+}
+export function taskForPush(task) {
+    const { enabled: _enabled, id: _id, remote_id: _remoteId, ...payload } = task;
+    return stripGeneratedFields(payload);
+}
+export async function nextAvailableSlug(project, baseSlug) {
+    const existing = new Set((await taskFiles(project)).map((filePath) => slugFromTaskFile(filePath)));
+    let candidate = baseSlug;
+    let suffix = 2;
+    while (existing.has(candidate)) {
+        candidate = `${baseSlug}-${suffix}`;
+        suffix += 1;
+    }
+    return candidate;
+}
+export async function taskFromHelperDir(dirPath) {
+    return stripTaskIds(await rawTaskFromHelperDir(dirPath));
+}
+export function helperDirForTaskFile(filePath) {
+    if (!filePath.toLowerCase().endsWith(".json")) {
+        return null;
+    }
+    return filePath.slice(0, -".json".length);
+}
+export async function unbundledHelperDirForTaskFile(filePath, task) {
+    const helperDir = helperDirForTaskFile(filePath);
+    if (!helperDir || !(await pathExists(path.join(helperDir, "task.json")))) {
+        return null;
+    }
+    const helperTask = await taskFromHelperDir(helperDir);
+    return stableStringify(taskForPush(helperTask)) === stableStringify(taskForPush(stripTaskIds(task))) ? null : helperDir;
+}
+export async function rawTaskFromHelperDir(dirPath) {
+    const base = await readJson(path.join(dirPath, "task.json"));
+    if (!base || typeof base !== "object" || Array.isArray(base)) {
+        throw new CliError(`${path.join(dirPath, "task.json")} must contain a JSON object`);
+    }
+    const task = stripHelperMetadata({ ...base });
+    for (const [field, fileName] of SPLIT_FILES) {
+        const filePath = path.join(dirPath, fileName);
+        if (await pathExists(filePath)) {
+            task[field] = await readText(filePath);
+        }
+    }
+    return task;
+}
+export async function unbundleTask(filePath, outDir) {
+    const task = await readTaskFile(filePath);
+    const taskJson = { ...task };
+    await ensureDir(outDir);
+    for (const [field, fileName] of SPLIT_FILES) {
+        const value = task[field];
+        const helperPath = path.join(outDir, fileName);
+        if (typeof value === "string") {
+            delete taskJson[field];
+            await writeText(helperPath, value);
+        }
+        else {
+            await removeFile(helperPath);
+        }
+    }
+    if (hasSubscriptionsTemplate(task)) {
+        delete taskJson.subscriptions;
+    }
+    await writeJson(path.join(outDir, "task.json"), taskJson);
+}
+export async function bundleTask(dirPath, outFile) {
+    await writeJson(outFile, await taskFromHelperDir(dirPath));
+}
+export function validateTask(task, source) {
+    const errors = [];
+    if ("id" in task || "remote_id" in task) {
+        errors.push("Task export must not include id or remote_id.");
+    }
+    if (typeof task.name !== "string" || task.name.trim() === "") {
+        errors.push("Task export must include a non-empty name.");
+    }
+    if ("script" in task && task.script !== null && typeof task.script !== "string") {
+        errors.push("script must be a string or null when present.");
+    }
+    if ("docs" in task && task.docs !== null && typeof task.docs !== "string") {
+        errors.push("docs must be a string or null when present.");
+    }
+    if ("subscriptions_template" in task
+        && task.subscriptions_template !== null
+        && typeof task.subscriptions_template !== "string") {
+        errors.push("subscriptions_template must be a string or null when present.");
+    }
+    if ("online_store_javascript" in task
+        && task.online_store_javascript !== null
+        && typeof task.online_store_javascript !== "string") {
+        errors.push("online_store_javascript must be a string or null when present.");
+    }
+    if ("order_status_javascript" in task
+        && task.order_status_javascript !== null
+        && typeof task.order_status_javascript !== "string") {
+        errors.push("order_status_javascript must be a string or null when present.");
+    }
+    if ("options" in task && (!task.options || typeof task.options !== "object" || Array.isArray(task.options))) {
+        errors.push("options must be an object when present.");
+    }
+    if ("preview_event_definitions" in task && !Array.isArray(task.preview_event_definitions)) {
+        errors.push("preview_event_definitions must be an array when present.");
+    }
+    if ("tags" in task && !Array.isArray(task.tags)) {
+        errors.push("tags must be an array when present.");
+    }
+    return {
+        ok: errors.length === 0,
+        source,
+        errors,
+    };
+}
+export function validateTaskForPush(task, source) {
+    return validateTask(task, source);
+}
+function comparableTaskValue(value) {
+    return value === undefined ? "(missing)" : String(stableStringify(value));
+}
+function taskValueLines(value) {
+    if (value === undefined) {
+        return ["(missing)"];
+    }
+    if (typeof value === "string") {
+        const lines = value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+        if (lines.length > 1 && lines[lines.length - 1] === "") {
+            lines.pop();
+        }
+        return lines;
+    }
+    return String(stableStringify(value)).split("\n");
+}
+function lineDiff(remoteLines, localLines) {
+    const scores = Array.from({ length: remoteLines.length + 1 }, () => (Array.from({ length: localLines.length + 1 }, () => 0)));
+    for (let remoteIndex = remoteLines.length - 1; remoteIndex >= 0; remoteIndex -= 1) {
+        for (let localIndex = localLines.length - 1; localIndex >= 0; localIndex -= 1) {
+            scores[remoteIndex][localIndex] = remoteLines[remoteIndex] === localLines[localIndex]
+                ? scores[remoteIndex + 1][localIndex + 1] + 1
+                : Math.max(scores[remoteIndex + 1][localIndex], scores[remoteIndex][localIndex + 1]);
+        }
+    }
+    const operations = [];
+    let remoteIndex = 0;
+    let localIndex = 0;
+    while (remoteIndex < remoteLines.length || localIndex < localLines.length) {
+        if (remoteIndex < remoteLines.length
+            && localIndex < localLines.length
+            && remoteLines[remoteIndex] === localLines[localIndex]) {
+            operations.push({ kind: "context", line: remoteLines[remoteIndex] });
+            remoteIndex += 1;
+            localIndex += 1;
+        }
+        else if (remoteIndex < remoteLines.length
+            && (localIndex >= localLines.length
+                || scores[remoteIndex + 1][localIndex] >= scores[remoteIndex][localIndex + 1])) {
+            operations.push({ kind: "remove", line: remoteLines[remoteIndex] });
+            remoteIndex += 1;
+        }
+        else {
+            operations.push({ kind: "add", line: localLines[localIndex] });
+            localIndex += 1;
+        }
+    }
+    return operations;
+}
+function formattedLineDiff(remoteLines, localLines) {
+    const operations = lineDiff(remoteLines, localLines);
+    const changeIndexes = operations.flatMap((operation, index) => (operation.kind === "context" ? [] : [index]));
+    if (changeIndexes.length === 0) {
+        return [];
+    }
+    const contextLineCount = 3;
+    const ranges = [];
+    for (const index of changeIndexes) {
+        const start = Math.max(0, index - contextLineCount);
+        const end = Math.min(operations.length - 1, index + contextLineCount);
+        const previous = ranges[ranges.length - 1];
+        if (previous && start <= previous.end + 1) {
+            previous.end = Math.max(previous.end, end);
+        }
+        else {
+            ranges.push({ start, end });
+        }
+    }
+    return ranges.flatMap((range) => {
+        const lines = ["@@"];
+        for (let index = range.start; index <= range.end; index += 1) {
+            const operation = operations[index];
+            const prefix = operation.kind === "add"
+                ? "+"
+                : operation.kind === "remove" ? "-" : " ";
+            lines.push(`${prefix}${operation.line}`);
+        }
+        return lines;
+    });
+}
+function formattedValueDiff(remoteValue, localValue) {
+    const lines = formattedLineDiff(taskValueLines(remoteValue), taskValueLines(localValue));
+    if (lines.length > 0) {
+        return lines;
+    }
+    return [
+        "@@",
+        `-${comparableTaskValue(remoteValue)}`,
+        `+${comparableTaskValue(localValue)}`,
+    ];
+}
+export function diffTasks(local, remote) {
+    const comparableLocal = stripGeneratedFields(local);
+    const comparableRemote = stripGeneratedFields(remote);
+    const fields = [...new Set([...Object.keys(comparableRemote), ...Object.keys(comparableLocal)])].sort();
+    const changedFields = fields.filter((field) => (comparableTaskValue(comparableLocal[field]) !== comparableTaskValue(comparableRemote[field])));
+    if (changedFields.length === 0) {
+        return null;
+    }
+    const sections = [`Changed fields: ${changedFields.join(", ")}`];
+    for (const field of changedFields) {
+        sections.push("", `## ${field}`, "--- remote", "+++ local", ...formattedValueDiff(comparableRemote[field], comparableLocal[field]));
+    }
+    return sections.join("\n");
+}

package/dist/types.d.ts

@@ -0,0 +1,144 @@
+export type JsonObject = Record<string, unknown>;
+export type MechanicConfig = {
+    shop_domain: string;
+    api_base_url: string;
+    app_url?: string;
+    tasks_dir: string;
+};
+export type LinkEntry = {
+    file: string;
+    remote_id: string;
+    last_remote_content_hash: string;
+};
+export type LinksFile = {
+    tasks: Record<string, LinkEntry>;
+};
+export type Project = {
+    cwd: string;
+    configPath: string;
+    linksPath: string;
+    shopDomain: string;
+    apiBaseUrl: string;
+    appUrl: string;
+    tasksDir: string;
+    tasksDirName: string;
+    links: LinksFile;
+};
+export type TaskEnvelope = {
+    id: string;
+    updated_at?: string;
+    content_hash: string;
+    task: JsonObject;
+};
+export type TaskListResponse = {
+    tasks: TaskEnvelope[];
+};
+export type TaskPreviewResponse = {
+    status: "passed" | "failed" | "invalid";
+    message?: string;
+    errors: Record<string, unknown>;
+    task: {
+        id?: string | null;
+        name?: string | null;
+        event_topics: string[];
+        shopify_api_version?: string | null;
+        shopify_access_scopes_required: string[];
+    };
+    source: {
+        kind: "local_draft" | "local_draft_for_existing_task" | "remote_current";
+        task_id?: string | null;
+        persisted: boolean;
+        remote_enabled?: boolean | null;
+    };
+    summary: {
+        events: number;
+        task_runs: number;
+        action_runs: number;
+        failed_task_runs: number;
+        failed_action_runs: number;
+        shopify_admin_api_requested: boolean;
+    };
+    permissions: {
+        required_by_preview: string[];
+        granted: {
+            app: string[];
+            task_runtime: string[];
+        };
+        missing: {
+            app: string[];
+            task_runtime: string[];
+        };
+        approval: {
+            required: boolean;
+            can_approve_from_api: boolean;
+            action: string;
+            app_url: string;
+        };
+        warnings: string[];
+    };
+    events: Array<{
+        topic: string;
+        shopify_topic?: string | null;
+        source?: string | null;
+        source_name?: string | null;
+        liquid_variable_names?: string[];
+        task_runs: Array<{
+            ok: boolean | null;
+            error?: string | null;
+            result?: string | null;
+            result_meta?: Record<string, unknown> | null;
+            action_runs: Array<{
+                action_type?: string | null;
+                ok: boolean | null;
+                error?: string | null;
+                result?: unknown;
+                result_meta?: Record<string, unknown> | null;
+            }>;
+        }>;
+    }>;
+};
+export type ShopStatusResponse = {
+    shop: {
+        shopify_domain: string;
+    };
+    queue: {
+        running: number | null;
+        limit: number | null;
+        available: number | null;
+        waiting: number | null;
+        oldest_waiting_ms: number | null;
+        partial: boolean;
+    };
+    running: {
+        event_runs: number | null;
+        task_runs: number | null;
+        action_runs: number | null;
+    };
+    backlog: {
+        event_runs: number | null;
+        task_runs: number | null;
+        action_runs: number | null;
+        by_event_topic: {
+            event_topic: string | null;
+            count: number;
+        }[];
+        by_task: {
+            task_id: string;
+            task_name?: string | null;
+            count: number;
+        }[];
+        by_action: {
+            action_type: string | null;
+            task_id: string;
+            task_name?: string | null;
+            count: number;
+        }[];
+    };
+    lag: {
+        event_run_ms: number | null;
+        task_run_ms: number | null;
+        action_run_ms: number | null;
+    };
+    checked_at: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};