@crouton-kit/crouter 0.2.6 → 0.3.1

package/dist/core/io.js

@@ -0,0 +1,83 @@
+// The agent-facing I/O contract. Flags and positional args on input; one JSON
+// object on stdout (JSONL for streams); structured errors; stderr is
+// diagnostics only and never carries the result. The stdout value is the next
+// caller's stdin. See cli-design SKILL.md / reference.md.
+import { CrtrError } from './errors.js';
+import { ExitCode } from '../types.js';
+/** A command-level failure: surfaces as the JSON response on stdout. */
+export class InputError extends CrtrError {
+    payload;
+    constructor(payload, exitCode = ExitCode.USAGE) {
+        super(payload.error, payload.message, exitCode, { ...payload });
+        this.name = 'InputError';
+        this.payload = payload;
+    }
+}
+// ---------------------------------------------------------------------------
+// stdin
+// ---------------------------------------------------------------------------
+/** Read raw stdin to EOF. Returns empty string when stdin is a TTY (no pipe).
+ *  Called by the argv parser for leaves declaring a `stdin` parameter. */
+export async function readStdinRaw() {
+    if (process.stdin.isTTY)
+        return '';
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString('utf8');
+}
+// ---------------------------------------------------------------------------
+// stdout — the result, nothing else
+// ---------------------------------------------------------------------------
+/** Single-shot response: one JSON object. The whole response is one value. */
+export function emit(obj) {
+    process.stdout.write(JSON.stringify(obj, null, 2) + '\n');
+}
+/** One JSONL record. Call per event in a stream; partial reads stay parseable. */
+export function emitLine(obj) {
+    process.stdout.write(JSON.stringify(obj) + '\n');
+}
+// ---------------------------------------------------------------------------
+// stderr — diagnostics the agent MAY capture, never the result
+// ---------------------------------------------------------------------------
+export function diag(message) {
+    process.stderr.write(message + '\n');
+}
+// ---------------------------------------------------------------------------
+// errors
+// ---------------------------------------------------------------------------
+function payloadOf(e) {
+    if (e instanceof InputError)
+        return e.payload;
+    const d = (e.details !== undefined ? e.details : {});
+    const next = d.next !== undefined
+        ? d.next
+        : 'Inspect the error and adjust the call. See -h for the schema.';
+    return {
+        error: e.code,
+        message: e.message,
+        received: d.received,
+        field: d.field,
+        next,
+    };
+}
+/** Terminal error handler. Command-level failures (bad input, not-found,
+ *  ambiguous) surface as the JSON response on stdout so the caller parses one
+ *  contract. Runtime/internal failures go to stderr as `{error:"internal"}` —
+ *  raw traces never reach the agent. Exits non-zero either way. */
+export function handle(e) {
+    if (e instanceof CrtrError) {
+        process.stdout.write(JSON.stringify(payloadOf(e), null, 2) + '\n');
+        process.exit(e.exitCode);
+    }
+    const err = e;
+    const message = err !== null && err !== undefined && typeof err.message === 'string'
+        ? err.message
+        : String(e);
+    process.stderr.write(JSON.stringify({
+        error: 'internal',
+        message,
+        next: 'This is a crtr bug, not a bad call. Retry; if it persists, report it.',
+    }, null, 2) + '\n');
+    process.exit(ExitCode.GENERAL);
+}

package/dist/core/jobs.d.ts

@@ -0,0 +1,87 @@
+type TerminalStatus = 'done' | 'failed' | 'canceled';
+type JobState = 'live' | TerminalStatus;
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Allocate a new job directory and write meta.json atomically.
+ * Returns the job_id and the absolute directory path.
+ */
+export declare function createJob(kind: string, opts: {
+    cwd: string;
+    pid?: number;
+}): {
+    jobId: string;
+    dir: string;
+};
+/**
+ * Record the tmux pane hosting a detached worker so `cancelJob` can kill it.
+ */
+export declare function recordJobPane(jobId: string, paneId: string): void;
+/**
+ * Append one event line to log.jsonl. Does NOT throw if jobId doesn't exist —
+ * a crashed writer should not further corrupt state; use a guard at the call site.
+ */
+export declare function appendEvent(jobId: string, event: {
+    level: LogLevel;
+    event: string;
+    message: string;
+    data?: object;
+}): void;
+/**
+ * Atomically write result.json and update meta.json status.
+ * result.json's appearance is the ONLY completion signal — never inferred from
+ * log content.
+ */
+export declare function writeResult(jobId: string, result: object, terminalStatus: TerminalStatus): void;
+/**
+ * Read result.json. If it doesn't exist and waitMs is given, block via fs.watch
+ * until result.json appears or the timeout elapses.
+ *
+ * Race safety: registers the watcher THEN re-stats. If result.json appeared
+ * between the first stat and the watch registration, the re-stat catches it
+ * before the watcher has a chance to miss it.
+ */
+export declare function readResult(jobId: string, opts?: {
+    waitMs?: number;
+}): Promise<{
+    status: 'done' | 'failed' | 'canceled' | 'timeout';
+    result?: object;
+}>;
+/**
+ * Derive job state from meta.json, result.json, and the tail of log.jsonl.
+ * If a pid is recorded, is not alive, and no result.json exists → 'failed'.
+ */
+export declare function jobStatus(jobId: string): {
+    state: JobState;
+    age_s: number;
+    last_event: {
+        event: string;
+        ts: string;
+    } | null;
+};
+/**
+ * List all jobs sorted by created_at ascending. Pagination is applied by the
+ * caller, not here.
+ */
+export declare function listJobs(): {
+    job_id: string;
+    kind: string;
+    state: JobState;
+    created_at: string;
+}[];
+/**
+ * Read and filter log events. Ordering preserved. sinceTs/untilTs are ISO8601
+ * strings; minLevel filters by severity rank (inclusive).
+ */
+export declare function readLog(jobId: string, opts?: {
+    sinceTs?: string;
+    untilTs?: string;
+    minLevel?: LogLevel;
+}): object[];
+/**
+ * Best-effort cancel: send SIGTERM to the recorded pid (if any), mark meta
+ * canceled. Success means the signal was delivered, not that execution stopped.
+ */
+export declare function cancelJob(jobId: string): {
+    canceled: boolean;
+};
+export {};

package/dist/core/jobs.js

@@ -0,0 +1,353 @@
+// Job / long-running-operation infrastructure.
+//
+// Files are the single source of truth. No in-memory registry. An agent picks
+// up a job by id across processes. Crashes recover by reading files.
+//
+// Layout: ${XDG_STATE_HOME or ~/.local/state}/crtr/jobs/<job_id>/
+//   meta.json    — written atomically on create; updated atomically on terminal transition.
+//   log.jsonl    — append-only event log.
+//   result.json  — written atomically; its APPEARANCE is the only completion signal.
+import { existsSync, mkdirSync, appendFileSync, readFileSync, writeFileSync, renameSync, readdirSync, statSync, } from 'node:fs';
+import { watch } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomBytes } from 'node:crypto';
+import { notFound, general } from './errors.js';
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+function jobsRoot() {
+    const xdg = process.env['XDG_STATE_HOME'];
+    const base = (xdg !== undefined && xdg !== '') ? xdg : join(homedir(), '.local', 'state');
+    return join(base, 'crtr', 'jobs');
+}
+function jobDir(jobId) {
+    return join(jobsRoot(), jobId);
+}
+function metaPath(jobId) {
+    return join(jobDir(jobId), 'meta.json');
+}
+function logPath(jobId) {
+    return join(jobDir(jobId), 'log.jsonl');
+}
+function resultPath(jobId) {
+    return join(jobDir(jobId), 'result.json');
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function generateJobId() {
+    const ts = Date.now().toString(36);
+    const rnd = randomBytes(4).toString('hex');
+    return `${ts}-${rnd}`;
+}
+function ensureJobsRoot() {
+    mkdirSync(jobsRoot(), { recursive: true });
+}
+function readMeta(jobId) {
+    const p = metaPath(jobId);
+    if (!existsSync(p)) {
+        throw notFound(`job not found: ${jobId}`, { job_id: jobId });
+    }
+    try {
+        return JSON.parse(readFileSync(p, 'utf8'));
+    }
+    catch {
+        throw general(`failed to parse meta.json for job ${jobId}`, { job_id: jobId });
+    }
+}
+function writeMeta(jobId, meta) {
+    const dir = jobDir(jobId);
+    const tmp = join(dir, '.meta.tmp');
+    writeFileSync(tmp, JSON.stringify(meta, null, 2), 'utf8');
+    renameSync(tmp, metaPath(jobId));
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const LEVEL_RANK = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+// ---------------------------------------------------------------------------
+// Exported API
+// ---------------------------------------------------------------------------
+/**
+ * Allocate a new job directory and write meta.json atomically.
+ * Returns the job_id and the absolute directory path.
+ */
+export function createJob(kind, opts) {
+    ensureJobsRoot();
+    const jobId = generateJobId();
+    const dir = jobDir(jobId);
+    mkdirSync(dir, { recursive: true });
+    const meta = {
+        job_id: jobId,
+        kind,
+        created_at: new Date().toISOString(),
+        cwd: opts.cwd,
+        status: 'live',
+    };
+    if (opts.pid !== undefined) {
+        meta.pid = opts.pid;
+    }
+    writeMeta(jobId, meta);
+    return { jobId, dir };
+}
+/**
+ * Record the tmux pane hosting a detached worker so `cancelJob` can kill it.
+ */
+export function recordJobPane(jobId, paneId) {
+    const meta = readMeta(jobId);
+    meta.pane_id = paneId;
+    writeMeta(jobId, meta);
+}
+/**
+ * Append one event line to log.jsonl. Does NOT throw if jobId doesn't exist —
+ * a crashed writer should not further corrupt state; use a guard at the call site.
+ */
+export function appendEvent(jobId, event) {
+    const p = logPath(jobId);
+    const line = {
+        ts: new Date().toISOString(),
+        level: event.level,
+        event: event.event,
+        message: event.message,
+    };
+    if (event.data !== undefined) {
+        line.data = event.data;
+    }
+    appendFileSync(p, JSON.stringify(line) + '\n', 'utf8');
+}
+/**
+ * Atomically write result.json and update meta.json status.
+ * result.json's appearance is the ONLY completion signal — never inferred from
+ * log content.
+ */
+export function writeResult(jobId, result, terminalStatus) {
+    const dir = jobDir(jobId);
+    if (!existsSync(dir)) {
+        throw notFound(`job not found: ${jobId}`, { job_id: jobId });
+    }
+    const payload = {
+        status: terminalStatus,
+        result,
+        written_at: new Date().toISOString(),
+    };
+    // Atomic write: tmp + rename within same directory (same fs, rename is atomic).
+    const tmp = join(dir, '.result.tmp');
+    writeFileSync(tmp, JSON.stringify(payload, null, 2), 'utf8');
+    renameSync(tmp, resultPath(jobId));
+    // Update meta status.
+    const meta = readMeta(jobId);
+    meta.status = terminalStatus;
+    writeMeta(jobId, meta);
+}
+/**
+ * Read result.json. If it doesn't exist and waitMs is given, block via fs.watch
+ * until result.json appears or the timeout elapses.
+ *
+ * Race safety: registers the watcher THEN re-stats. If result.json appeared
+ * between the first stat and the watch registration, the re-stat catches it
+ * before the watcher has a chance to miss it.
+ */
+export function readResult(jobId, opts = {}) {
+    const dir = jobDir(jobId);
+    if (!existsSync(dir)) {
+        throw notFound(`job not found: ${jobId}`, { job_id: jobId });
+    }
+    function parseResult() {
+        const raw = readFileSync(resultPath(jobId), 'utf8');
+        const parsed = JSON.parse(raw);
+        return { status: parsed.status, result: parsed.result };
+    }
+    // Fast path: result already present.
+    if (existsSync(resultPath(jobId))) {
+        const r = parseResult();
+        return Promise.resolve({ status: r.status, result: r.result });
+    }
+    if (opts.waitMs === undefined || opts.waitMs <= 0) {
+        return Promise.resolve({ status: 'timeout' });
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (status, result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                watcher.close();
+            }
+            catch { /* noop */ }
+            resolve({ status, result });
+        };
+        // Register watcher first, then re-stat (race safety).
+        const watcher = watch(dir, (_event, name) => {
+            if (name === 'result.json' && existsSync(resultPath(jobId))) {
+                const r = parseResult();
+                finish(r.status, r.result);
+            }
+        });
+        // Re-stat after watcher is registered to close the race window.
+        if (existsSync(resultPath(jobId))) {
+            const r = parseResult();
+            finish(r.status, r.result);
+            return;
+        }
+        const timer = setTimeout(() => {
+            finish('timeout');
+        }, opts.waitMs);
+    });
+}
+/**
+ * Derive job state from meta.json, result.json, and the tail of log.jsonl.
+ * If a pid is recorded, is not alive, and no result.json exists → 'failed'.
+ */
+export function jobStatus(jobId) {
+    const meta = readMeta(jobId);
+    const age_s = (Date.now() - new Date(meta.created_at).getTime()) / 1000;
+    // Derive effective state.
+    let state = meta.status;
+    if (state === 'live') {
+        if (existsSync(resultPath(jobId))) {
+            // result.json present but meta not yet updated (rare); trust the file.
+            try {
+                const r = JSON.parse(readFileSync(resultPath(jobId), 'utf8'));
+                state = r.status;
+            }
+            catch { /* leave as live */ }
+        }
+        else if (meta.pid !== undefined && !pidAlive(meta.pid)) {
+            state = 'failed';
+        }
+    }
+    // Tail of log for last_event.
+    let last_event = null;
+    const lp = logPath(jobId);
+    if (existsSync(lp)) {
+        const lines = readFileSync(lp, 'utf8').trimEnd().split('\n');
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i];
+            if (line === undefined || line.trim() === '')
+                continue;
+            try {
+                const ev = JSON.parse(line);
+                last_event = { event: ev.event, ts: ev.ts };
+                break;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return { state, age_s, last_event };
+}
+/**
+ * List all jobs sorted by created_at ascending. Pagination is applied by the
+ * caller, not here.
+ */
+export function listJobs() {
+    const root = jobsRoot();
+    if (!existsSync(root))
+        return [];
+    const entries = readdirSync(root);
+    const jobs = [];
+    for (const entry of entries) {
+        const dir = join(root, entry);
+        try {
+            if (!statSync(dir).isDirectory())
+                continue;
+            const mp = join(dir, 'meta.json');
+            if (!existsSync(mp))
+                continue;
+            const meta = JSON.parse(readFileSync(mp, 'utf8'));
+            // Derive effective state (result.json beats meta.status for live jobs).
+            let state = meta.status;
+            if (state === 'live' && existsSync(join(dir, 'result.json'))) {
+                try {
+                    const r = JSON.parse(readFileSync(join(dir, 'result.json'), 'utf8'));
+                    state = r.status;
+                }
+                catch { /* leave as live */ }
+            }
+            jobs.push({ job_id: meta.job_id, kind: meta.kind, state, created_at: meta.created_at });
+        }
+        catch {
+            continue;
+        }
+    }
+    jobs.sort((a, b) => a.created_at.localeCompare(b.created_at));
+    return jobs;
+}
+/**
+ * Read and filter log events. Ordering preserved. sinceTs/untilTs are ISO8601
+ * strings; minLevel filters by severity rank (inclusive).
+ */
+export function readLog(jobId, opts = {}) {
+    const dir = jobDir(jobId);
+    if (!existsSync(dir)) {
+        throw notFound(`job not found: ${jobId}`, { job_id: jobId });
+    }
+    const lp = logPath(jobId);
+    if (!existsSync(lp))
+        return [];
+    const raw = readFileSync(lp, 'utf8');
+    const results = [];
+    const minRank = opts.minLevel !== undefined ? LEVEL_RANK[opts.minLevel] : 0;
+    for (const line of raw.split('\n')) {
+        if (line.trim() === '')
+            continue;
+        let ev;
+        try {
+            ev = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (opts.sinceTs !== undefined && ev.ts < opts.sinceTs)
+            continue;
+        if (opts.untilTs !== undefined && ev.ts >= opts.untilTs)
+            continue;
+        if (LEVEL_RANK[ev.level] < minRank)
+            continue;
+        results.push(ev);
+    }
+    return results;
+}
+/**
+ * Best-effort cancel: send SIGTERM to the recorded pid (if any), mark meta
+ * canceled. Success means the signal was delivered, not that execution stopped.
+ */
+export function cancelJob(jobId) {
+    const meta = readMeta(jobId);
+    if (meta.status !== 'live') {
+        // Already terminal — nothing to cancel.
+        return { canceled: false };
+    }
+    let signaled = false;
+    if (meta.pid !== undefined) {
+        try {
+            process.kill(meta.pid, 'SIGTERM');
+            signaled = true;
+        }
+        catch { /* pid gone or unpermitted */ }
+    }
+    if (meta.pane_id !== undefined && meta.pane_id !== '') {
+        const k = spawnSync('tmux', ['kill-pane', '-t', meta.pane_id], { encoding: 'utf8' });
+        if (k.status === 0)
+            signaled = true;
+    }
+    meta.status = 'canceled';
+    writeMeta(jobId, meta);
+    return { canceled: signaled };
+}

package/dist/core/pagination.d.ts

@@ -0,0 +1,33 @@
+/** Encodes a stable sort key into an opaque base64url cursor token. */
+export declare function encodeCursor(key: string): string;
+/** Decodes an opaque cursor token back to the sort key it encodes.
+ *  Throws `CrtrError` with code `'invalid_cursor'` on malformed input. */
+export declare function decodeCursor(token: string): string;
+export interface PaginateResult<T> {
+    items: T[];
+    next_cursor: string | null;
+    total: number | null;
+}
+export interface PaginateOpts<T> {
+    /** Default page size when `params.limit` is absent. */
+    defaultLimit: number;
+    /** Hard cap; `params.limit` is clamped to [1, maxLimit]. */
+    maxLimit: number;
+    /** Returns the stable sort key for an item. Must match the sort order of the
+     *  input array — ascending by this key. */
+    keyOf: (item: T) => string;
+    /** 'count' → compute and return `total`; 'omit' → return `null`. */
+    total: 'count' | 'omit';
+}
+/**
+ * Returns one page of items from a pre-sorted list, with a stable opaque
+ * cursor for resumption.
+ *
+ * @param allItemsSortedAscByKey - Full dataset, sorted ascending by `keyOf`.
+ * @param params - Agent-supplied `{ limit?, cursor? }` from stdin.
+ * @param opts - Caller-supplied configuration (limits, key extractor, total).
+ */
+export declare function paginate<T>(allItemsSortedAscByKey: T[], params: {
+    limit?: number;
+    cursor?: string;
+}, opts: PaginateOpts<T>): PaginateResult<T>;

package/dist/core/pagination.js

@@ -0,0 +1,89 @@
+// Pagination helper for agent-facing paginated list leaves.
+//
+// Precondition: `allItemsSortedAscByKey` MUST be sorted ascending by the value
+// `keyOf` returns. Sort order is part of each leaf's contract — this module
+// trusts the caller. Violating the precondition produces silently wrong pages.
+//
+// Cursor design: encodes the stable sort key of the last-emitted item as
+// base64url JSON `{k: <sortKey>}`. Resumption seeks the first item whose key
+// is strictly greater than the cursor key — stable under inserts and deletes
+// between pages (a deleted cursor key simply doesn't stall the scan; the next
+// item after it is returned correctly).
+import { CrtrError } from './errors.js';
+import { ExitCode } from '../types.js';
+// ---------------------------------------------------------------------------
+// Cursor encoding / decoding
+// ---------------------------------------------------------------------------
+/** Encodes a stable sort key into an opaque base64url cursor token. */
+export function encodeCursor(key) {
+    const json = JSON.stringify({ k: key });
+    return Buffer.from(json, 'utf8').toString('base64url');
+}
+/** Decodes an opaque cursor token back to the sort key it encodes.
+ *  Throws `CrtrError` with code `'invalid_cursor'` on malformed input. */
+export function decodeCursor(token) {
+    let json;
+    try {
+        json = Buffer.from(token, 'base64url').toString('utf8');
+    }
+    catch {
+        throw new CrtrError('invalid_cursor', 'cursor could not be decoded.', ExitCode.USAGE, {
+            received: token,
+            next: 'Omit cursor to restart from the beginning.',
+        });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        throw new CrtrError('invalid_cursor', 'cursor payload is not valid JSON.', ExitCode.USAGE, {
+            received: token,
+            next: 'Omit cursor to restart from the beginning.',
+        });
+    }
+    if (typeof parsed !== 'object' ||
+        parsed === null ||
+        !('k' in parsed) ||
+        typeof parsed.k !== 'string') {
+        throw new CrtrError('invalid_cursor', 'cursor payload is missing required key field.', ExitCode.USAGE, {
+            received: token,
+            next: 'Omit cursor to restart from the beginning.',
+        });
+    }
+    return parsed.k;
+}
+/**
+ * Returns one page of items from a pre-sorted list, with a stable opaque
+ * cursor for resumption.
+ *
+ * @param allItemsSortedAscByKey - Full dataset, sorted ascending by `keyOf`.
+ * @param params - Agent-supplied `{ limit?, cursor? }` from stdin.
+ * @param opts - Caller-supplied configuration (limits, key extractor, total).
+ */
+export function paginate(allItemsSortedAscByKey, params, opts) {
+    // Resolve effective limit: clamp to [1, maxLimit], default when absent.
+    const rawLimit = params.limit !== undefined ? params.limit : opts.defaultLimit;
+    const effectiveLimit = Math.min(Math.max(1, rawLimit), opts.maxLimit);
+    // Resolve start position from cursor.
+    let startIndex = 0;
+    if (params.cursor !== undefined) {
+        const cursorKey = decodeCursor(params.cursor); // throws CrtrError on bad cursor
+        // Find the first item whose key is strictly greater than cursorKey.
+        // Linear scan; callers with large datasets should pre-filter upstream.
+        startIndex = allItemsSortedAscByKey.findIndex((item) => opts.keyOf(item) > cursorKey);
+        if (startIndex === -1) {
+            // All items are at or before the cursor key — list is exhausted.
+            startIndex = allItemsSortedAscByKey.length;
+        }
+    }
+    const page = allItemsSortedAscByKey.slice(startIndex, startIndex + effectiveLimit);
+    // next_cursor: null is the ONLY end-of-list signal.
+    let next_cursor = null;
+    if (page.length === effectiveLimit && startIndex + effectiveLimit < allItemsSortedAscByKey.length) {
+        const lastKey = opts.keyOf(page[page.length - 1]);
+        next_cursor = encodeCursor(lastKey);
+    }
+    const total = opts.total === 'count' ? allItemsSortedAscByKey.length : null;
+    return { items: page, next_cursor, total };
+}

package/dist/core/self-update.d.ts

@@ -0,0 +1,21 @@
+export declare function currentVersion(): string;
+export declare function selfUpdate(): void;
+/** Check whether a newer crtr version is available on npm.
+ *  Warns to stderr if network unavailable; returns {current, latest} or null if unreachable. */
+export declare function selfCheck(): {
+    current: string;
+    latest: string;
+} | null;
+/** Pull updates for all installed marketplaces and standalone plugins. */
+export declare function contentUpdate(): void;
+export interface ContentUpdateEntry {
+    name: string;
+    kind: 'marketplace' | 'plugin';
+    current: string | null;
+    latest: string | null;
+    up_to_date: boolean;
+    unreachable: boolean;
+}
+/** Check whether any marketplace/plugin has updates available.
+ *  Returns per-item status without applying anything. */
+export declare function contentCheck(): ContentUpdateEntry[];