@aria-cli/tools 1.0.12 → 1.0.14

package/dist/network-runtime/local-control-contract.js

@@ -1,627 +0,0 @@
-import { z } from "zod";
-import { ClientIdSchema, ControlEndpointAdvertisementSchema, EndpointRevisionSchema, InboxAddressSchema, NodeIdSchema, PrincipalFingerprintSchema, PeerTransportIdSchema, RuntimeIdSchema, TlsCaFingerprintSchema, TransportEndpointAdvertisementSchema, } from "./address-types.js";
-import { canonicalizeDeliveryReceipt, DeliveryReceiptInputSchema, RuntimeTransportSchema, DeliveryStateSchema, SessionStateSchema, DeliveryReadinessSchema, QueuedReasonSchema, } from "./delivery-receipts.js";
-import { AcceptInviteRequestSchema } from "./pair-route-contract.js";
-import { PeerIdentityStateSchema, PeerTransportStateSchema } from "./peer-state-machine.js";
-const NonEmptyStringSchema = z.string().trim().min(1);
-const AutonomySchema = z.enum(["minimal", "balanced", "high", "full"]);
-const ToolNameListSchema = z.array(z.string()).optional();
-const MessageHistorySchema = z.array(z.custom()).optional();
-function toFastifyBodyJsonSchema(schema) {
-    const jsonSchema = z.toJSONSchema(schema);
-    delete jsonSchema.$schema;
-    return jsonSchema;
-}
-export { AcceptInviteRequestSchema };
-export const RunRequestSchema = z
-    .object({
-    task: NonEmptyStringSchema,
-    arion: NonEmptyStringSchema.optional(),
-    cwd: NonEmptyStringSchema.optional(),
-    history: MessageHistorySchema,
-    requestedModel: NonEmptyStringSchema.optional(),
-    preferredTier: z.enum(["fast", "balanced", "powerful", "ensemble"]).optional(),
-    budget: z.number().positive().optional(),
-    maxTurns: z.number().int().positive().optional(),
-    autonomy: AutonomySchema.optional(),
-    allowedTools: ToolNameListSchema,
-    deniedTools: ToolNameListSchema,
-    noMemory: z.boolean().optional(),
-    systemPrompt: z.string().optional(),
-    approvalMode: z.enum(["pause", "approve", "deny"]).optional(),
-    askUserAnswers: z.array(z.string()).optional(),
-})
-    .strict();
-export const RuntimeErrorDiagnosticSchema = z.lazy(() => z
-    .object({
-    message: z.string(),
-    name: z.string().optional(),
-    stack: z.string().optional(),
-    cause: RuntimeErrorDiagnosticSchema.optional(),
-})
-    .catchall(z.unknown()));
-function extractRuntimeDiagnosticMessage(diagnostic) {
-    if (!diagnostic || typeof diagnostic !== "object") {
-        return undefined;
-    }
-    const message = diagnostic.message;
-    if (typeof message !== "string") {
-        return undefined;
-    }
-    const trimmed = message.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-function isGenericTrustedRuntimeMessage(message) {
-    const normalized = message.trim().toLowerCase();
-    return (normalized === "internal server error" ||
-        normalized.startsWith("internal server error:") ||
-        normalized.startsWith("http 500"));
-}
-export function resolveTrustedRuntimeErrorMessage(message, diagnostic) {
-    const fallback = typeof message === "string" && message.trim().length > 0 ? message : undefined;
-    const diagnosticMessage = extractRuntimeDiagnosticMessage(diagnostic);
-    if (!diagnosticMessage) {
-        return fallback;
-    }
-    if (!fallback || isGenericTrustedRuntimeMessage(fallback)) {
-        return diagnosticMessage;
-    }
-    return fallback;
-}
-export function createTrustedRuntimeError(message, diagnostic) {
-    const resolvedMessage = resolveTrustedRuntimeErrorMessage(message, diagnostic) ?? "Trusted runtime error";
-    return Object.assign(new Error(resolvedMessage), {
-        ...(diagnostic === undefined ? {} : { diagnostic }),
-        ...(typeof message === "string" && message.trim().length > 0 && message !== resolvedMessage
-            ? { publicMessage: message }
-            : {}),
-    });
-}
-export const RunResultSchema = z
-    .object({
-    success: z.boolean(),
-    output: z.string().optional(),
-    messages: z.array(z.unknown()).optional(),
-    toolCalls: z.array(z.unknown()).optional(),
-    usage: z.unknown().optional(),
-    turnCount: z.number().int().nonnegative().optional(),
-    thinking: z.array(z.unknown()).optional(),
-    nativeToolResults: z.array(z.unknown()).optional(),
-    traces: z.array(z.unknown()).optional(),
-    pipelineTiming: z.unknown().optional(),
-    guardrailEvents: z.array(z.unknown()).optional(),
-    handoffs: z.array(z.unknown()).optional(),
-    state: z.unknown().optional(),
-    error: z.string().optional(),
-    diagnostic: RuntimeErrorDiagnosticSchema.optional(),
-})
-    .strict();
-export const ResumeRunRequestSchema = z
-    .object({
-    state: z.unknown(),
-    arion: NonEmptyStringSchema.optional(),
-    cwd: NonEmptyStringSchema.optional(),
-    requestedModel: NonEmptyStringSchema.optional(),
-    preferredTier: z.enum(["fast", "balanced", "powerful", "ensemble"]).optional(),
-    budget: z.number().positive().optional(),
-    maxTurns: z.number().int().positive().optional(),
-    autonomy: AutonomySchema.optional(),
-    allowedTools: ToolNameListSchema,
-    deniedTools: ToolNameListSchema,
-    noMemory: z.boolean().optional(),
-    systemPrompt: z.string().optional(),
-    approvalMode: z.enum(["pause", "approve", "deny"]).optional(),
-    askUserAnswers: z.array(z.string()).optional(),
-})
-    .strict();
-export const RuntimeRunEventSchema = z.discriminatedUnion("type", [
-    z.object({
-        type: z.literal("text_delta"),
-        content: z.string(),
-    }),
-    z.object({
-        type: z.literal("tool_start"),
-        id: NonEmptyStringSchema,
-        name: NonEmptyStringSchema,
-        input: z.unknown().optional(),
-    }),
-    z.object({
-        type: z.literal("approval_needed"),
-        toolName: NonEmptyStringSchema,
-        toolInput: z.unknown().optional(),
-        riskLevel: z.string().optional(),
-        issues: z.array(z.string()).optional(),
-    }),
-    z.object({
-        type: z.literal("tool_result"),
-        id: NonEmptyStringSchema,
-        name: NonEmptyStringSchema,
-        durationMs: z.number().nonnegative(),
-        result: z.unknown(),
-        input: z.unknown().optional(),
-    }),
-    z.object({
-        type: z.literal("usage_update"),
-        usage: z.unknown(),
-    }),
-    z.object({
-        type: z.literal("turn_complete"),
-        turnNumber: z.number().int().nonnegative(),
-    }),
-    z.object({
-        type: z.literal("guardrail_rejected"),
-        stage: z.enum(["input", "output"]),
-        message: z.string(),
-    }),
-    z.object({
-        type: z.literal("pipeline_timing"),
-        report: z.unknown(),
-    }),
-    z.object({
-        type: z.literal("messages_snapshot"),
-        messages: z.array(z.unknown()),
-    }),
-    z.object({
-        type: z.literal("error"),
-        error: z.object({
-            message: z.string(),
-            diagnostic: RuntimeErrorDiagnosticSchema.optional(),
-        }),
-    }),
-    z.object({
-        type: z.literal("native_tool_result"),
-        metadata: z.unknown(),
-    }),
-    z.object({
-        type: z.literal("thinking_start"),
-    }),
-    z.object({
-        type: z.literal("thinking_delta"),
-        content: z.string(),
-    }),
-    z.object({
-        type: z.literal("thinking_end"),
-        blocks: z.array(z.unknown()),
-        durationMs: z.number().nonnegative(),
-    }),
-    z.object({
-        type: z.literal("tool_args_delta"),
-        id: NonEmptyStringSchema,
-        args: z.string(),
-    }),
-    z.object({
-        type: z.literal("span_start"),
-        spanId: NonEmptyStringSchema,
-        spanType: NonEmptyStringSchema,
-        name: NonEmptyStringSchema,
-    }),
-    z.object({
-        type: z.literal("span_end"),
-        spanId: NonEmptyStringSchema,
-        durationMs: z.number().nonnegative(),
-    }),
-    z.object({
-        type: z.literal("handoff_start"),
-        target: NonEmptyStringSchema,
-        id: NonEmptyStringSchema,
-    }),
-    z.object({
-        type: z.literal("handoff_result"),
-        target: NonEmptyStringSchema,
-        result: z.string(),
-        id: NonEmptyStringSchema,
-    }),
-    z.object({
-        type: z.literal("paused"),
-        state: z.unknown(),
-    }),
-]);
-export const RuntimeQueuedReceiptSchema = z
-    .object(DeliveryReceiptInputSchema.shape)
-    .strict()
-    .transform((receipt) => canonicalizeDeliveryReceipt(receipt));
-export const RuntimeDeliveryReceiptSchema = z
-    .object({
-    transport: RuntimeTransportSchema,
-    delivered: z.boolean(),
-    queued: z.boolean(),
-    accepted: z.boolean().optional(),
-    deliveryState: DeliveryStateSchema.optional(),
-    sessionState: SessionStateSchema.optional(),
-    deliveryReadiness: DeliveryReadinessSchema.optional(),
-    queuedReason: QueuedReasonSchema.optional(),
-    storedAt: z.number().int().nonnegative().optional(),
-})
-    .strict()
-    .transform(({ storedAt, ...receipt }) => ({
-    ...canonicalizeDeliveryReceipt(receipt),
-    ...(storedAt !== undefined ? { storedAt } : {}),
-}));
-export const OutboundMessageSchema = z
-    .object({
-    rawMessage: z.record(z.string(), z.unknown()),
-    recipientInbox: InboxAddressSchema.optional(),
-    to: NonEmptyStringSchema.optional(),
-    content: z.string().optional(),
-    type: NonEmptyStringSchema.optional(),
-    priority: z.number().int().optional(),
-    correlationId: z.string().optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-})
-    .strict()
-    .superRefine((message, ctx) => {
-    if (!message.recipientInbox || message.to === undefined) {
-        return;
-    }
-    if (message.recipientInbox.kind === "client") {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: 'OutboundMessage.to is a compatibility alias for node recipients only; omit it for recipientInbox.kind === "client"',
-            path: ["to"],
-        });
-        return;
-    }
-    if (message.recipientInbox.nodeId !== message.to) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "OutboundMessage.recipientInbox.nodeId must match OutboundMessage.to when both are provided",
-            path: ["to"],
-        });
-    }
-});
-export const RuntimeEventCursorSchema = z
-    .object({
-    afterRevision: z.number().int().nonnegative().optional(),
-})
-    .strict();
-export const InboxCursorSchema = z
-    .object({
-    afterCreatedAt: z.number().int().nonnegative().optional(),
-})
-    .strict();
-export const InboxListRequestSchema = z
-    .object({
-    cursor: InboxCursorSchema.optional(),
-    limit: z.number().int().positive().max(1000).optional(),
-    unreadOnly: z.boolean().optional(),
-})
-    .strict();
-export const PersistedInboxEventSchema = z
-    .object({
-    id: NonEmptyStringSchema,
-    senderNodeId: NodeIdSchema,
-    senderDisplayNameSnapshot: NonEmptyStringSchema.optional(),
-    senderType: NonEmptyStringSchema.optional(),
-    senderClientId: z.string().nullable().optional(),
-    recipientClientId: z.string().nullable().optional(),
-    inboxAddress: InboxAddressSchema,
-    type: NonEmptyStringSchema,
-    content: z.string(),
-    priority: z.number().int(),
-    createdAt: z.number().int().nonnegative(),
-    correlationId: z.string().nullable().optional(),
-    replyTo: z.string().nullable().optional(),
-})
-    .strict();
-export const PeerViewEventSchema = z
-    .object({
-    nodeId: NodeIdSchema,
-    transportPublicKey: PeerTransportIdSchema,
-    displayNameSnapshot: NonEmptyStringSchema.optional(),
-    identityState: PeerIdentityStateSchema,
-    transportState: PeerTransportStateSchema,
-    endpointRevision: EndpointRevisionSchema,
-    updatedAt: z.string(),
-    lastSeenAt: z.string().optional(),
-})
-    .strict();
-export const NearbyPeerViewSchema = z
-    .object({
-    displayNameSnapshot: NonEmptyStringSchema,
-    nodeId: NodeIdSchema,
-    host: NonEmptyStringSchema,
-    port: z.number().int().min(1).max(65535),
-    principalFingerprint: PrincipalFingerprintSchema,
-    version: NonEmptyStringSchema,
-    tlsCaFingerprint: TlsCaFingerprintSchema.optional(),
-    transport: z.enum(["lan", "wan"]).optional(),
-    status: z.enum(["discovered", "connected"]).optional(),
-})
-    .strict();
-export const RuntimeAutonomousLoopSafetyPolicySummarySchema = z
-    .object({
-    allowedToolCategories: z.array(NonEmptyStringSchema).optional(),
-    allowedShellCommands: z.array(NonEmptyStringSchema).optional(),
-    maxWriteOpsPerMinute: z.number().int().positive().optional(),
-    maxGitPushesPerHour: z.number().int().positive().optional(),
-})
-    .strict();
-export const RuntimeAutonomousLoopStatusSchema = z
-    .object({
-    status: z.enum(["running", "stopped"]),
-    intervalMs: z.number().int().positive().nullable(),
-    lastWakeTickAt: z.string().nullable(),
-    lastCheckpointResult: z.enum(["success", "error", "never"]),
-    safetyPolicySummary: RuntimeAutonomousLoopSafetyPolicySummarySchema,
-    ownerClientKind: NonEmptyStringSchema.nullable(),
-})
-    .strict();
-function createDefaultRuntimeAutonomousLoopStatus() {
-    return {
-        status: "stopped",
-        intervalMs: null,
-        lastWakeTickAt: null,
-        lastCheckpointResult: "never",
-        safetyPolicySummary: {},
-        ownerClientKind: null,
-    };
-}
-export const RuntimeStatusSchema = z
-    .object({
-    nodeId: NodeIdSchema,
-    runtimeId: RuntimeIdSchema,
-    port: z.number().int().min(1).max(65535),
-    attachedClients: z.number().int().nonnegative().optional(),
-    autonomousLoop: RuntimeAutonomousLoopStatusSchema.optional().default(createDefaultRuntimeAutonomousLoopStatus()),
-})
-    .strict();
-export const RuntimeAutonomousLoopCommandSchema = z
-    .object({
-    intervalMs: z.number().int().positive().optional(),
-    safetyPolicy: RuntimeAutonomousLoopSafetyPolicySummarySchema.optional(),
-})
-    .strict();
-export const PendingPairRequestViewSchema = z
-    .object({
-    id: NonEmptyStringSchema,
-    nodeId: NodeIdSchema,
-    displayNameSnapshot: NonEmptyStringSchema.optional(),
-    principalFingerprint: PrincipalFingerprintSchema,
-})
-    .strict();
-export const PendingInviteViewSchema = z
-    .object({
-    inviteId: NonEmptyStringSchema,
-    inviteLabel: NonEmptyStringSchema.optional(),
-    createdAt: NonEmptyStringSchema,
-    expiresAt: NonEmptyStringSchema.nullable().optional(),
-})
-    .strict();
-export const PairRequestDecisionSchema = z
-    .object({
-    requestId: NonEmptyStringSchema,
-    accepted: z.boolean(),
-})
-    .strict();
-export const PairRequestResponseSchema = z
-    .object({
-    accepted: z.boolean().optional(),
-    inviteToken: z.string().optional(),
-    error: z.string().optional(),
-})
-    .strict();
-export const CreateInviteRequestSchema = z
-    .object({
-    inviteLabel: NonEmptyStringSchema.optional(),
-    durationMs: z.number().int().min(0).optional(),
-})
-    .strict();
-export const CreateInviteResponseSchema = z
-    .object({
-    inviteToken: NonEmptyStringSchema,
-    pendingInvite: PendingInviteViewSchema,
-})
-    .strict();
-export const InvitePeerRequestSchema = z
-    .object({
-    nodeId: NodeIdSchema,
-    displayName: NonEmptyStringSchema,
-    principalFingerprint: PrincipalFingerprintSchema.optional(),
-    controlEndpoint: ControlEndpointAdvertisementSchema,
-    transportEndpoint: TransportEndpointAdvertisementSchema.optional(),
-    transport: z.enum(["lan", "wan"]).optional(),
-})
-    .strict();
-export const PairingProofStateSchema = z.enum(["pending_verification"]);
-export const InvitePeerResultSchema = z.discriminatedUnion("mode", [
-    z
-        .object({
-        nodeId: NodeIdSchema,
-        displayNameSnapshot: NonEmptyStringSchema.optional(),
-        mode: z.literal("lan_direct"),
-        pairingProofState: z.literal("pending_verification"),
-    })
-        .strict(),
-    z
-        .object({
-        nodeId: NodeIdSchema,
-        displayNameSnapshot: NonEmptyStringSchema.optional(),
-        mode: z.literal("wan_pair"),
-        pairingProofState: z.literal("pending_verification"),
-    })
-        .strict(),
-]);
-export const AcceptInviteResponseSchema = z
-    .object({
-    success: z.boolean(),
-    nodeId: NodeIdSchema,
-    displayNameSnapshot: NonEmptyStringSchema.optional(),
-})
-    .strict();
-export const AcceptInviteTokenRequestSchema = z
-    .object({
-    inviteToken: NonEmptyStringSchema,
-})
-    .strict();
-export const AcceptInviteTokenResponseSchema = AcceptInviteResponseSchema;
-export const CancelInviteRequestSchema = z
-    .object({
-    inviteId: NonEmptyStringSchema,
-})
-    .strict();
-export const CancelInviteResponseSchema = z
-    .object({
-    cancelled: z.boolean(),
-    inviteId: NonEmptyStringSchema,
-})
-    .strict();
-export const DirectPairRequestSchema = z
-    .object({
-    peerNodeId: NodeIdSchema,
-    principalFingerprint: PrincipalFingerprintSchema,
-    peerDisplayName: NonEmptyStringSchema.optional(),
-    peerWgPubkey: PeerTransportIdSchema,
-    peerSigningPubkey: NonEmptyStringSchema,
-    transportEndpoint: TransportEndpointAdvertisementSchema,
-    controlEndpoint: ControlEndpointAdvertisementSchema,
-    psk: NonEmptyStringSchema,
-})
-    .strict();
-export const DirectPairRequestJsonSchema = toFastifyBodyJsonSchema(DirectPairRequestSchema);
-export const DirectPairResponseSchema = z
-    .object({
-    received: z.literal(true),
-    pairingProofState: z.literal("pending_verification"),
-})
-    .strict();
-export const RevokePeerRequestSchema = z
-    .object({
-    nodeId: NodeIdSchema,
-    envelope: z.record(z.string(), z.unknown()).optional(),
-})
-    .strict();
-export const RevokePeerResponseSchema = z
-    .object({
-    revoked: z.boolean(),
-    nodeId: NodeIdSchema,
-    displayNameSnapshot: NonEmptyStringSchema.optional(),
-})
-    .strict();
-export const RepairPeerRequestSchema = z
-    .object({
-    nodeId: NodeIdSchema,
-    endpointHost: NonEmptyStringSchema,
-    endpointPort: z.number().int().min(1).max(65535),
-    endpointRevision: EndpointRevisionSchema,
-})
-    .strict();
-export const RepairPeerResponseSchema = z
-    .object({
-    repaired: z.boolean(),
-    nodeId: NodeIdSchema,
-    endpointHost: NonEmptyStringSchema,
-    endpointPort: z.number().int().min(1).max(65535),
-    endpointRevision: EndpointRevisionSchema,
-})
-    .strict();
-export const LocalControlClientKindSchema = z.enum(["tui", "daemon-launcher", "pipe", "local-api"]);
-export const AttachedClientViewSchema = z
-    .object({
-    clientId: ClientIdSchema,
-    clientKind: LocalControlClientKindSchema,
-    displayLabel: NonEmptyStringSchema,
-    self: z.boolean(),
-    attachedAt: NonEmptyStringSchema,
-    lastSeenAt: NonEmptyStringSchema,
-})
-    .strict();
-export const AttachedClientLeaseGrantSchema = z
-    .object({
-    clientId: ClientIdSchema,
-    clientAuthToken: NonEmptyStringSchema,
-})
-    .strict();
-export const AttachedClientAuthSchema = AttachedClientLeaseGrantSchema;
-export const LocalControlSocketAttachClientRequestSchema = z
-    .object({
-    clientKind: LocalControlClientKindSchema,
-    lease: z.boolean().optional(),
-    pid: z.number().optional(),
-    displayName: z.string().optional(),
-})
-    .strict();
-export const LocalControlSocketAttachClientResponseSchema = AttachedClientLeaseGrantSchema;
-export const LocalControlSocketDetachClientRequestSchema = z
-    .object({
-    clientId: ClientIdSchema,
-})
-    .strict();
-export const LocalControlSocketDetachClientResponseSchema = z
-    .object({
-    detached: z.boolean(),
-})
-    .strict();
-export const LocalControlSocketMethodSchema = z.enum([
-    "submitRun",
-    "resumeRun",
-    "streamRun",
-    "subscribeRuntimeEvents",
-    "sendBestEffort",
-    "sendDurable",
-    "listInbox",
-    "listDirectClientInbox",
-    "listPeers",
-    "listNearbyPeers",
-    "listAttachedClients",
-    "subscribeDirectClientInbox",
-    "getRuntimeStatus",
-    "startAutonomousLoop",
-    "stopAutonomousLoop",
-    "getRuntimeBootstrap",
-    "listPendingPairRequests",
-    "respondToPairRequest",
-    "createInvite",
-    "listPendingInvites",
-    "acceptInviteToken",
-    "cancelInvite",
-    "invitePeer",
-    "acceptInvite",
-    "directPair",
-    "revokePeer",
-    "repairPeer",
-    "attachClient",
-    "detachClient",
-    "watchInbox",
-]);
-const AttachedClientAuthRequiredSocketMethods = new Set([
-    "listAttachedClients",
-    "listDirectClientInbox",
-    "subscribeDirectClientInbox",
-]);
-export const LocalControlSocketRequestSchema = z
-    .object({
-    id: NonEmptyStringSchema,
-    method: LocalControlSocketMethodSchema,
-    payload: z.unknown().optional(),
-    auth: AttachedClientAuthSchema.optional(),
-})
-    .strict()
-    .superRefine((request, ctx) => {
-    if (AttachedClientAuthRequiredSocketMethods.has(request.method) && request.auth === undefined) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: `Local control socket method ${request.method} requires attached-client auth`,
-            path: ["auth"],
-        });
-    }
-});
-export const LocalControlSocketSuccessResponseSchema = z
-    .object({
-    id: NonEmptyStringSchema,
-    ok: z.literal(true),
-    payload: z.unknown().optional(),
-})
-    .strict();
-export const LocalControlSocketErrorResponseSchema = z
-    .object({
-    id: NonEmptyStringSchema,
-    ok: z.literal(false),
-    error: NonEmptyStringSchema,
-    reason: z.string().optional(),
-    diagnostic: RuntimeErrorDiagnosticSchema.optional(),
-})
-    .strict();
-export const LocalControlSocketResponseSchema = z.discriminatedUnion("ok", [
-    LocalControlSocketSuccessResponseSchema,
-    LocalControlSocketErrorResponseSchema,
-]);

package/dist/network-runtime/node-store-contract.js

@@ -1,34 +0,0 @@
-import { z } from "zod";
-import { NodeIdSchema, RuntimeIdSchema, } from "./address-types.js";
-const NonEmptyStringSchema = z.string().trim().min(1);
-const RecordSchema = z.record(z.string(), z.unknown());
-export { RuntimeOwnerRecordSchema } from "./address-types.js";
-export const RuntimeEventKindSchema = z.enum([
-    "client_attached",
-    "client_detached",
-    "runtime_started",
-    "runtime_stopped",
-    "runtime_stale",
-    "runtime_restarted",
-    "pair_proposed",
-    "proof_committed",
-    "continuity_bound",
-    "revocation_committed",
-    "ingress_accepted",
-    "ingress_rejected",
-    "durable_send_queued",
-    "durable_send_dispatching",
-    "durable_send_acked",
-    "durable_send_expired",
-]);
-export const RuntimeEventSchema = z
-    .object({
-    eventId: NonEmptyStringSchema,
-    nodeId: NodeIdSchema,
-    runtimeId: RuntimeIdSchema,
-    kind: RuntimeEventKindSchema,
-    revision: z.number().int().nonnegative().optional(),
-    recordedAt: NonEmptyStringSchema,
-    payload: RecordSchema,
-})
-    .strict();