@osolmaz/pi-workflows 0.15.2 → 0.16.0

package/dist/client/resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.js","sourceRoot":"","sources":["../../src/client/resolver.ts"],"names":[],"mappings":""}

package/dist/client/view.d.ts

@@ -0,0 +1,118 @@
+import type { JsonValue } from "../state/json.js";
+export declare const RUN_VIEW_SCHEMA: "pi-workflows.run-view.v1";
+export declare const SESSION_VIEW_SCHEMA: "pi-workflows.session-view.v1";
+export type WorkflowDisplayStatus = "queued" | "running" | "waiting" | "paused" | "completed" | "failed" | "timed_out" | "cancelled" | "ambiguous";
+export type WorkflowDisplay = {
+    status: WorkflowDisplayStatus;
+    activity: "supervised_worker" | "origin_turn" | null;
+    controls: Array<"pause" | "resume" | "cancel" | "answer" | "review">;
+    reason: string | null;
+    reasonContent?: JsonValue;
+};
+export type WorkflowRunQueueView = {
+    runId: string;
+    workflowName: string;
+    workflowSourceRef: string;
+    initialized: boolean;
+    definitionDigest: string;
+    status: "queued" | "starting" | "running" | "parked" | "done" | "failed" | "cancelled";
+    originSessionId: string | null;
+    executionMode: "interactive" | "headless";
+    parentRunId: string | null;
+    errorCode: string | null;
+    createdAt: string;
+    updatedAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+};
+export type WorkflowRunView = {
+    schema: typeof RUN_VIEW_SCHEMA;
+    runId: string;
+    revision: number;
+    display: WorkflowDisplay;
+    manifest: JsonValue;
+    state: JsonValue;
+    workflow: JsonValue;
+    queue: WorkflowRunQueueView;
+    updates: JsonValue[];
+    graphSteps: JsonValue[];
+    graphStepStart: number;
+    graphStepTotal: number;
+    takenTransitions: string[];
+    graphHistory: JsonValue;
+    takenTransitionStart: number;
+    takenTransitionTotal: number;
+    graphCursor: number;
+    stepStart: number;
+    stepTotal: number;
+    tracePage: JsonValue;
+    session: JsonValue;
+    settingsScopes: JsonValue[];
+    settingsStart: number;
+    settingsTotal: number;
+    followUpQueue: JsonValue;
+    followUpStart: number;
+    followUpTotal: number;
+    updateStart: number;
+    updateTotal: number;
+    live: boolean;
+    possiblyInterrupted: boolean;
+};
+export type WorkflowRunListPage = {
+    schema: "pi-workflows.run-list-page.v1";
+    revision: string;
+    start: number;
+    total: number;
+    items: WorkflowRunSummary[];
+};
+export type WorkflowRunSummary = {
+    runId: string;
+    workflowName: string;
+    originSessionId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    display: WorkflowDisplay;
+    manifest: JsonValue;
+    live: boolean;
+    possiblyInterrupted: boolean;
+};
+export type ClientInteractiveRequest = {
+    requestId: string;
+    runId: string;
+    attemptId: string;
+    targetSessionId: string;
+    kind: "agent" | "assistant" | "decision";
+    contract: JsonValue;
+    revision: number;
+    status: "pending" | "presenting" | "settled" | "cancelled";
+    presenterId: string | null;
+    presentationClaimExpiresAt: string | null;
+    presentationSessionEntryId: string | null;
+    acceptedSubmissionId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    settledAt: string | null;
+    consumedAt: string | null;
+};
+export type WorkflowDeliveryAvailability = {
+    notification: boolean;
+    turn: boolean;
+};
+export type WorkflowSessionView = {
+    schema: typeof SESSION_VIEW_SCHEMA;
+    sessionId: string;
+    run: WorkflowRunView | null;
+    pendingInteractions: JsonValue[];
+    pendingInteractionStart: number;
+    pendingInteractionTotal: number;
+    deliveries: WorkflowDeliveryAvailability;
+};
+export type OriginActivityReport = {
+    sessionId: string;
+    runId: string;
+    requestId: string;
+    deliveryId: string;
+    sessionEntryId: string;
+    sequence: number;
+    state: "started" | "refresh" | "settled";
+};

package/dist/client/view.js

@@ -0,0 +1,3 @@
+export const RUN_VIEW_SCHEMA = "pi-workflows.run-view.v1";
+export const SESSION_VIEW_SCHEMA = "pi-workflows.session-view.v1";
+//# sourceMappingURL=view.js.map

package/dist/client/view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view.js","sourceRoot":"","sources":["../../src/client/view.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,eAAe,GAAG,0BAAmC,CAAC;AACnE,MAAM,CAAC,MAAM,mBAAmB,GAAG,8BAAuC,CAAC"}

package/dist/controllers/sqlite.d.ts

@@ -22,6 +22,26 @@ export type WorkflowRunClaimOptions = WorkflowRunReservationOptions & {
     claimToken: string;
     leaseMs: number;
 };
+export type WorkflowRunQueueViewRecord = {
+    runId: string;
+    workflowName: string;
+    workflowSourceRef: string;
+    workflowSource: unknown;
+    initialized: boolean;
+    definitionDigest: string;
+    runStateStatus: string;
+    paused: boolean;
+    status: WorkflowRunLaunchStatus;
+    originSessionId: string | null;
+    executionMode: "interactive" | "headless";
+    parentRunId: string | null;
+    errorCode: string | null;
+    errorMessage: string | null;
+    createdAt: string;
+    updatedAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+};
 export type WorkflowRunQueueRecord = {
     runId: string;
     workflowName: string;
@@ -212,6 +232,19 @@ export declare class SqliteControllerStore implements ControllerStore {
     prepareOrAdoptWorkflowRun(options: WorkflowRunClaimOptions): WorkflowRunPreparationResult;
     enqueueWorkflowRun(options: WorkflowRunClaimOptions): WorkflowRunQueueRecord;
     getWorkflowRun(runId: string): WorkflowRunQueueRecord | undefined;
+    getWorkflowRunView(runId: string): WorkflowRunQueueViewRecord | undefined;
+    workflowRunListRevision(): {
+        total: number;
+        revision: string;
+    };
+    listWorkflowRunViews(options: {
+        offset: number;
+        limit: number;
+    }): {
+        total: number;
+        revision: string;
+        runs: WorkflowRunQueueViewRecord[];
+    };
     workflowRunProjectPath(runId: string): string | undefined;
     listWorkflowRuns(options?: {
         statuses?: WorkflowRunLaunchStatus[];
@@ -219,6 +252,7 @@ export declare class SqliteControllerStore implements ControllerStore {
         limit?: number;
     }): WorkflowRunQueueRecord[];
     findSessionReservation(sessionId: string): WorkflowRunQueueRecord | undefined;
+    findSessionReservationView(sessionId: string): WorkflowRunQueueViewRecord | undefined;
     claimWorkflowRun(options: {
         runId: string;
         runnerId: string;
@@ -287,6 +321,15 @@ export declare class SqliteControllerStore implements ControllerStore {
         claimToken: string;
         now?: string;
     }): boolean;
+    pauseParkedWorkflowRun(options: {
+        runId: string;
+        now?: string;
+    }): boolean;
+    resumePausedInteraction(options: {
+        runId: string;
+        now?: string;
+    }): boolean;
+    isWorkflowRunPaused(runId: string): boolean;
     parkWorkflowRunForSourceChange(options: {
         runId: string;
         claimToken: string;
@@ -357,6 +400,12 @@ export declare class SqliteControllerStore implements ControllerStore {
         runId: string;
         targetSessionId: string;
     }): WorkflowTurnIntentRecord | undefined;
+    isWorkflowTurnIntentClaimLive(options: {
+        intentId: string;
+        targetSessionId: string;
+        claimToken: string;
+        now?: string;
+    }): boolean;
     claimWorkflowTurnIntent(options: {
         intentId: string;
         targetSessionId: string;
@@ -371,6 +420,10 @@ export declare class SqliteControllerStore implements ControllerStore {
         now?: string;
         limit?: number;
     }): WorkflowTurnIntentRecord[];
+    hasClaimableWorkflowTurnIntent(options: {
+        targetSessionId: string;
+        now?: string;
+    }): boolean;
     makeWorkflowTurnIntentEligible(options: {
         intentId: string;
         fallbackFacts: WorkflowTurnIntentFacts;
@@ -406,6 +459,10 @@ export declare class SqliteControllerStore implements ControllerStore {
         content: string;
         now?: string;
     }): WorkflowNotificationRecord;
+    hasClaimableWorkflowNotification(options: {
+        targetSessionId: string;
+        now?: string;
+    }): boolean;
     listPendingWorkflowNotifications(options: {
         targetSessionId: string;
         limit?: number;
@@ -417,6 +474,12 @@ export declare class SqliteControllerStore implements ControllerStore {
         now?: string;
         limit?: number;
     }): WorkflowNotificationRecord[];
+    isWorkflowNotificationClaimLive(options: {
+        notificationId: string;
+        targetSessionId: string;
+        claimToken: string;
+        now?: string;
+    }): boolean;
     markWorkflowNotificationDelivered(options: {
         notificationId: string;
         targetSessionId: string;
@@ -457,6 +520,7 @@ export declare class SqliteControllerStore implements ControllerStore {
     private requireWorkflowRunRow;
     private requireWorkflowRun;
     private assertWorkflowRunPreparationCompatible;
+    private workflowRunViewRows;
     private mapWorkflowRun;
     private claimRun;
     private claimRunInTransaction;

package/dist/controllers/sqlite.js

@@ -640,6 +640,32 @@ export class SqliteControllerStore {
         const row = this.workflowRunRow(runId);
         return row === undefined ? undefined : this.mapWorkflowRun(row);
     }
+    getWorkflowRunView(runId) {
+        const row = this.workflowRunViewRows("WHERE r.run_id = ?", [runId])[0];
+        return row === undefined ? undefined : workflowRunViewRecord(row);
+    }
+    workflowRunListRevision() {
+        const row = this.state.connection
+            .prepare(`SELECT count(*) AS count, COALESCE(sum(res.revision), 0) AS revisionSum,
+                COALESCE(max(q.updated_at), 0) AS updatedAt
+         FROM runs r JOIN run_queue q ON q.run_id = r.run_id
+         JOIN resources res ON res.resource_id = r.resource_id`)
+            .get();
+        if (!isRunListRevisionRow(row))
+            throw new Error("Workflow run list revision is invalid");
+        return {
+            total: row.count,
+            revision: `${row.count}:${row.revisionSum}:${row.updatedAt}`,
+        };
+    }
+    listWorkflowRunViews(options) {
+        const current = this.workflowRunListRevision();
+        const rows = this.workflowRunViewRows("ORDER BY q.created_at DESC LIMIT ? OFFSET ?", [
+            options.limit,
+            options.offset,
+        ]);
+        return { ...current, runs: rows.map(workflowRunViewRecord) };
+    }
     workflowRunProjectPath(runId) {
         const row = this.state.connection
             .prepare(`SELECT p.canonical_path AS canonicalPath
@@ -662,9 +688,10 @@ export class SqliteControllerStore {
             clauses.push(`r.run_id NOT IN (${options.excludeRunIds.map(() => "?").join(", ")})`);
             params.push(...options.excludeRunIds);
         }
-        params.push(options.limit ?? 100);
+        if (options.limit !== undefined)
+            params.push(options.limit);
         const rows = this.state.connection
-            .prepare(workflowRunSelect(`${clauses.length === 0 ? "" : `WHERE ${clauses.join(" AND ")}`} ORDER BY q.created_at DESC LIMIT ?`))
+            .prepare(workflowRunSelect(`${clauses.length === 0 ? "" : `WHERE ${clauses.join(" AND ")}`} ORDER BY q.created_at DESC${options.limit === undefined ? "" : " LIMIT ?"}`))
             .all(...params);
         return rows.filter(isRunRow).map((row) => this.mapWorkflowRun(row));
     }
@@ -674,6 +701,10 @@ export class SqliteControllerStore {
             .get(sessionId);
         return isRunRow(row) ? this.mapWorkflowRun(row) : undefined;
     }
+    findSessionReservationView(sessionId) {
+        const row = this.workflowRunViewRows("WHERE b.origin_session_id = ? AND q.status NOT IN ('done', 'failed', 'cancelled') ORDER BY q.created_at DESC LIMIT 1", [sessionId])[0];
+        return row === undefined ? undefined : workflowRunViewRecord(row);
+    }
     claimWorkflowRun(options) {
         const now = epoch(validTimestamp(options.now));
         return this.claimRun(options.runId, options.runnerId, options.claimToken, options.leaseMs, now);
@@ -832,6 +863,74 @@ export class SqliteControllerStore {
     parkWorkflowRun(options) {
         return this.releaseRunClaim(options.runId, options.claimToken, "parked", options.now);
     }
+    pauseParkedWorkflowRun(options) {
+        const now = epoch(validTimestamp(options.now));
+        return this.state.transaction(() => {
+            const row = this.workflowRunRow(options.runId);
+            if (row === undefined || row.status !== "parked")
+                return false;
+            const lease = this.requireLease(row.resourceId);
+            if (lease.ownerId !== null && lease.expiresAt !== null && lease.expiresAt > now)
+                return false;
+            const pending = this.state.connection
+                .prepare(`SELECT 1 FROM interactive_requests
+           WHERE run_id = ? AND status IN ('pending', 'presenting') LIMIT 1`)
+                .get(options.runId);
+            if (pending === undefined)
+                return false;
+            if (row.paused === 1)
+                return true;
+            if (!["running", "waiting"].includes(row.runStatus))
+                return false;
+            const changed = this.state.connection
+                .prepare(`UPDATE runs SET paused = 1, status_detail = 'paused', updated_at = ?
+           WHERE run_id = ? AND paused = 0 AND status IN ('running', 'waiting')`)
+                .run(now, options.runId);
+            if (changed.changes !== 1)
+                return false;
+            const revision = this.resourceRevision(row.resourceId);
+            this.bumpResource(row.resourceId, revision, now);
+            this.insertEvent(row.resourceId, revision + 1, "run.paused", "control", null, { status: "parked" }, now);
+            recordViewerDeltas(this.state, options.runId, [{ targetType: "summary" }, { targetType: "replay" }], now);
+            return true;
+        });
+    }
+    resumePausedInteraction(options) {
+        const now = epoch(validTimestamp(options.now));
+        return this.state.transaction(() => {
+            const row = this.workflowRunRow(options.runId);
+            if (row === undefined ||
+                row.status !== "parked" ||
+                row.runStatus !== "waiting" ||
+                row.paused !== 1) {
+                return false;
+            }
+            const lease = this.requireLease(row.resourceId);
+            if (lease.ownerId !== null && lease.expiresAt !== null && lease.expiresAt > now)
+                return false;
+            const pending = this.state.connection
+                .prepare(`SELECT 1 FROM interactive_requests
+           WHERE run_id = ? AND status IN ('pending', 'presenting') LIMIT 1`)
+                .get(options.runId);
+            if (pending === undefined)
+                return false;
+            const changed = this.state.connection
+                .prepare(`UPDATE runs
+           SET paused = 0, status_detail = 'waiting for origin-session input', updated_at = ?
+           WHERE run_id = ? AND status = 'waiting' AND paused = 1`)
+                .run(now, options.runId);
+            if (changed.changes !== 1)
+                return false;
+            const revision = this.resourceRevision(row.resourceId);
+            this.bumpResource(row.resourceId, revision, now);
+            this.insertEvent(row.resourceId, revision + 1, "run.resumed", "control", null, { status: "waiting" }, now);
+            recordViewerDeltas(this.state, options.runId, [{ targetType: "summary" }, { targetType: "replay" }], now);
+            return true;
+        });
+    }
+    isWorkflowRunPaused(runId) {
+        return this.workflowRunRow(runId)?.paused === 1;
+    }
     parkWorkflowRunForSourceChange(options) {
         const now = epoch(validTimestamp(options.now));
         return this.state.transaction(() => {
@@ -1109,6 +1208,13 @@ export class SqliteControllerStore {
             .get(options.runId, options.targetSessionId);
         return isTurnIntentRow(row) ? this.mapTurnIntent(row) : undefined;
     }
+    isWorkflowTurnIntentClaimLive(options) {
+        const row = this.turnIntentRow(options.intentId);
+        return (row !== undefined &&
+            row.targetSessionId === options.targetSessionId &&
+            row.resolvedAt === null &&
+            this.verifyEffectToken(row.effectId, options.claimToken, options.now));
+    }
     claimWorkflowTurnIntent(options) {
         const intent = this.turnIntent(options.intentId);
         if (intent?.targetSessionId !== options.targetSessionId)
@@ -1131,6 +1237,21 @@ export class SqliteControllerStore {
         }
         return claimed;
     }
+    hasClaimableWorkflowTurnIntent(options) {
+        const now = epoch(validTimestamp(options.now));
+        const row = this.state.connection
+            .prepare(`SELECT 1 AS present
+         FROM turn_intents t
+         JOIN effects e ON e.effect_id = t.effect_id
+         JOIN leases l ON l.resource_id = e.resource_id
+         WHERE t.target_session_id = ? AND t.resolved_at IS NULL
+           AND t.eligible_at IS NOT NULL AND t.eligible_at <= ?
+           AND e.status = 'pending'
+           AND (l.owner_id IS NULL OR l.expires_at IS NULL OR l.expires_at <= ?)
+         LIMIT 1`)
+            .get(options.targetSessionId, now, now);
+        return row !== undefined;
+    }
     makeWorkflowTurnIntentEligible(options) {
         const eligibleAt = epoch(validTimestamp(options.eligibleAt ?? options.now));
         const factsHash = this.state.putJson(options.fallbackFacts, eligibleAt);
@@ -1209,6 +1330,19 @@ export class SqliteControllerStore {
         });
         return this.requireNotification(options.runId, options.attemptId, options.notificationIndex);
     }
+    hasClaimableWorkflowNotification(options) {
+        const now = epoch(validTimestamp(options.now));
+        const row = this.state.connection
+            .prepare(`SELECT 1 AS present
+         FROM notifications n
+         JOIN effects e ON e.effect_id = n.effect_id
+         JOIN leases l ON l.resource_id = e.resource_id
+         WHERE n.target_session_id = ? AND e.status = 'pending'
+           AND (l.owner_id IS NULL OR l.expires_at IS NULL OR l.expires_at <= ?)
+         LIMIT 1`)
+            .get(options.targetSessionId, now);
+        return row !== undefined;
+    }
     listPendingWorkflowNotifications(options) {
         const now = Date.now();
         return this.notificationRows(options.targetSessionId, options.limit ?? 20)
@@ -1226,6 +1360,12 @@ export class SqliteControllerStore {
         }
         return result;
     }
+    isWorkflowNotificationClaimLive(options) {
+        const row = this.notificationRowById(options.notificationId);
+        return (row !== undefined &&
+            row.targetSessionId === options.targetSessionId &&
+            this.verifyEffectToken(row.effectId, options.claimToken, options.now));
+    }
     markWorkflowNotificationDelivered(options) {
         const now = epoch(validTimestamp(options.now));
         return this.state.transaction(() => {
@@ -1597,6 +1737,12 @@ export class SqliteControllerStore {
             throw new Error(`Workflow run preparation conflicts: ${options.runId}`);
         }
     }
+    workflowRunViewRows(clause, params) {
+        return this.state.connection
+            .prepare(workflowRunViewSelect(clause))
+            .all(...params)
+            .filter(isWorkflowRunViewRow);
+    }
     /* istanbul ignore next -- pure projection covered by integration tests */
     mapWorkflowRun(row) {
         return {
@@ -2024,7 +2170,7 @@ function workflowSelect(clause) {
 function workflowRunSelect(clause) {
     return `SELECT r.run_id AS runId, r.resource_id AS resourceId,
     d.workflow_name AS workflowName, r.workflow_ref AS workflowRef, r.status AS runStatus,
-    r.definition_digest AS definitionDigest, d.definition_hash AS definitionHash,
+    r.paused, r.definition_digest AS definitionDigest, d.definition_hash AS definitionHash,
     r.input_hash AS inputHash,
     r.launch_options_hash AS launchOptionsHash,
     q.status, q.available_at AS availableAt, q.affinity_runner_id AS affinityRunnerId,
@@ -2039,6 +2185,23 @@ function workflowRunSelect(clause) {
     LEFT JOIN run_bindings b ON b.run_id = r.run_id
     JOIN leases l ON l.resource_id = r.resource_id ${clause}`;
 }
+function workflowRunViewSelect(clause) {
+    return `SELECT r.run_id AS runId, d.workflow_name AS workflowName,
+    r.workflow_ref AS workflowRef, r.status AS runStatus, r.paused,
+    r.definition_digest AS definitionDigest, q.status,
+    b.origin_session_id AS originSessionId, b.execution_mode AS executionMode,
+    r.parent_run_id AS parentRunId, q.error_code AS errorCode,
+    CAST(error.content AS TEXT) AS errorMessage,
+    q.created_at AS createdAt, q.updated_at AS updatedAt,
+    q.started_at AS startedAt, q.finished_at AS finishedAt,
+    source.source_type AS sourceType, source.source_ref AS sourceRef,
+    source.source_revision AS sourceRevision
+    FROM runs r JOIN workflow_definitions d ON d.definition_digest = r.definition_digest
+    JOIN run_queue q ON q.run_id = r.run_id
+    LEFT JOIN run_bindings b ON b.run_id = r.run_id
+    LEFT JOIN run_sources source ON source.run_id = r.run_id AND source.mount_path = ''
+    LEFT JOIN blobs error ON error.blob_hash = q.error_hash ${clause}`;
+}
 function turnIntentSelect(clause) {
     return `SELECT t.turn_intent_id AS intentId, t.source_event_id AS sourceEventId,
     t.run_id AS runId, t.workflow_ref AS workflowRef,
@@ -2071,6 +2234,59 @@ function isControllerRow(value) {
 function isLeaseRow(value) {
     return isRecord(value);
 }
+function workflowRunViewRecord(row) {
+    const root = row.sourceType === "builtin"
+        ? { kind: "builtin", id: row.sourceRef, revision: row.sourceRevision }
+        : { kind: "file", path: row.sourceRef, hash: row.sourceRevision };
+    return {
+        runId: row.runId,
+        workflowName: row.workflowName,
+        workflowSourceRef: row.workflowRef,
+        workflowSource: { root, mounted: [] },
+        initialized: row.runStatus !== "queued",
+        definitionDigest: `sha256:${row.definitionDigest.toString("hex")}`,
+        runStateStatus: row.runStatus,
+        paused: row.paused === 1,
+        status: row.status,
+        originSessionId: row.executionMode === "headless" ? null : row.originSessionId,
+        executionMode: row.executionMode,
+        parentRunId: row.parentRunId,
+        errorCode: row.errorCode,
+        errorMessage: row.errorMessage,
+        createdAt: new Date(row.createdAt).toISOString(),
+        updatedAt: new Date(row.updatedAt).toISOString(),
+        startedAt: row.startedAt === null ? null : new Date(row.startedAt).toISOString(),
+        finishedAt: row.finishedAt === null ? null : new Date(row.finishedAt).toISOString(),
+    };
+}
+function isWorkflowRunViewRow(value) {
+    return (isRecord(value) &&
+        typeof value.runId === "string" &&
+        typeof value.workflowName === "string" &&
+        typeof value.workflowRef === "string" &&
+        typeof value.runStatus === "string" &&
+        typeof value.paused === "number" &&
+        Buffer.isBuffer(value.definitionDigest) &&
+        typeof value.status === "string" &&
+        (value.originSessionId === null || typeof value.originSessionId === "string") &&
+        (value.executionMode === "interactive" || value.executionMode === "headless") &&
+        (value.parentRunId === null || typeof value.parentRunId === "string") &&
+        (value.errorCode === null || typeof value.errorCode === "string") &&
+        (value.errorMessage === null || typeof value.errorMessage === "string") &&
+        typeof value.createdAt === "number" &&
+        typeof value.updatedAt === "number" &&
+        (value.startedAt === null || typeof value.startedAt === "number") &&
+        (value.finishedAt === null || typeof value.finishedAt === "number") &&
+        (value.sourceType === "builtin" || value.sourceType === "file") &&
+        typeof value.sourceRef === "string" &&
+        typeof value.sourceRevision === "string");
+}
+function isRunListRevisionRow(value) {
+    return (isRecord(value) &&
+        typeof value.count === "number" &&
+        typeof value.revisionSum === "number" &&
+        typeof value.updatedAt === "number");
+}
 function isRunRow(value) {
     return isRecord(value);
 }