@astrale-os/kernel-core 0.9.0-beta.9 → 1.0.0-beta.2

package/dist/schema/kernel/syscalls/contracts/installation.d.ts

@@ -1,357 +1,71 @@
-import { z } from 'zod';
 import { operationIdSchema } from '../../../installation/operation-id.js';
 export { operationIdSchema };
-export declare const installationText: z.ZodString;
-export declare const installationDigest: z.ZodString;
-export declare const artifactRef: z.ZodObject<{
-    digest: z.ZodString;
-    mediaType: z.ZodString;
-    size: z.ZodNumber;
-}, z.core.$strict>;
-export declare const dependencyReadinessCoordinate: z.ZodObject<{
-    origin: z.ZodString;
-    installation: z.ZodString;
-    target: z.ZodString;
-    readinessReceipt: z.ZodString;
-    meaningComparison: z.ZodString;
-}, z.core.$strict>;
-export declare const serviceTarget: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"local">;
-    artifact: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"remote">;
-    etag: z.ZodString;
-}, z.core.$strict>], "kind">;
-export declare const installationTarget: z.ZodObject<{
-    origin: z.ZodString;
-    schemaRevision: z.ZodString;
-    schemaBundle: z.ZodString;
-    service: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"local">;
-        artifact: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"remote">;
-        etag: z.ZodString;
-    }, z.core.$strict>], "kind">;
-    capabilities: z.ZodObject<{
-        functions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        classes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            class: z.ZodObject<{
-                origin: z.ZodString;
-                kind: z.ZodLiteral<"class">;
-                name: z.ZodString;
-            }, z.core.$strict>;
-            operations: z.ZodArray<z.ZodEnum<{
-                create: "create";
-                delete: "delete";
-                read: "read";
-                traverse: "traverse";
-                update: "update";
-            }>>;
-        }, z.core.$strict>>>;
-        admin: z.ZodOptional<z.ZodObject<{
-            grant: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                create: "create";
-                delete: "delete";
-                grant: "grant";
-                read: "read";
+export declare const installationText: import("zod").ZodString;
+export declare const installationDigest: import("zod").ZodString;
+export declare const artifactRef: import("zod").ZodObject<{
+    digest: import("zod").ZodString;
+    mediaType: import("zod").ZodString;
+    size: import("zod").ZodNumber;
+}, import("zod/v4/core").$strict>;
+export declare const issuerConsent: import("zod").ZodObject<{
+    issuer: import("zod").ZodObject<{
+        from: import("zod").ZodString;
+        to: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>;
+    previous: import("zod").ZodOptional<import("zod").ZodEnum<{
+        drain: "drain";
+        revoke: "revoke";
+    }>>;
+}, import("zod/v4/core").$strict>;
+export declare const readinessReceipt: import("zod").ZodObject<{
+    generation: import("zod").ZodString;
+    transition: import("zod").ZodString;
+    dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+        origin: import("zod").ZodString;
+        generation: import("zod").ZodString;
+        readiness: import("zod").ZodString;
+        meaning: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>;
+export declare const transitionReceipt: import("zod").ZodObject<{
+    intent: import("zod").ZodObject<{
+        transition: import("zod").ZodString;
+        operation: import("zod").ZodString;
+        origin: import("zod").ZodString;
+        previous: import("zod").ZodNullable<import("zod").ZodObject<{
+            origin: import("zod").ZodString;
+            revision: import("zod").ZodString;
+            generation: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+        generation: import("zod").ZodNullable<import("zod").ZodObject<{
+            origin: import("zod").ZodString;
+            revision: import("zod").ZodString;
+            generation: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+        consent: import("zod").ZodOptional<import("zod").ZodObject<{
+            issuer: import("zod").ZodObject<{
+                from: import("zod").ZodString;
+                to: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>;
+            previous: import("zod").ZodEnum<{
+                drain: "drain";
                 revoke: "revoke";
-                traverse: "traverse";
-                update: "update";
-                use: "use";
-            }>>>;
-            revoke: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                create: "create";
-                delete: "delete";
-                grant: "grant";
-                read: "read";
-                revoke: "revoke";
-                traverse: "traverse";
-                update: "update";
-                use: "use";
-            }>>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-    dependencies: z.ZodArray<z.ZodObject<{
-        origin: z.ZodString;
-        installation: z.ZodString;
-        target: z.ZodString;
-        readinessReceipt: z.ZodString;
-        meaningComparison: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const transitionIntent: z.ZodObject<{
-    transition: z.ZodString;
-    operation: z.ZodString;
-    installation: z.ZodString;
-    origin: z.ZodString;
-    source: z.ZodNullable<z.ZodObject<{
-        origin: z.ZodString;
-        schemaRevision: z.ZodString;
-        schemaBundle: z.ZodString;
-        service: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"local">;
-            artifact: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"remote">;
-            etag: z.ZodString;
-        }, z.core.$strict>], "kind">;
-        capabilities: z.ZodObject<{
-            functions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            classes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                class: z.ZodObject<{
-                    origin: z.ZodString;
-                    kind: z.ZodLiteral<"class">;
-                    name: z.ZodString;
-                }, z.core.$strict>;
-                operations: z.ZodArray<z.ZodEnum<{
-                    create: "create";
-                    delete: "delete";
-                    read: "read";
-                    traverse: "traverse";
-                    update: "update";
-                }>>;
-            }, z.core.$strict>>>;
-            admin: z.ZodOptional<z.ZodObject<{
-                grant: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                    create: "create";
-                    delete: "delete";
-                    grant: "grant";
-                    read: "read";
-                    revoke: "revoke";
-                    traverse: "traverse";
-                    update: "update";
-                    use: "use";
-                }>>>;
-                revoke: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                    create: "create";
-                    delete: "delete";
-                    grant: "grant";
-                    read: "read";
-                    revoke: "revoke";
-                    traverse: "traverse";
-                    update: "update";
-                    use: "use";
-                }>>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-        dependencies: z.ZodArray<z.ZodObject<{
-            origin: z.ZodString;
-            installation: z.ZodString;
-            target: z.ZodString;
-            readinessReceipt: z.ZodString;
-            meaningComparison: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    target: z.ZodNullable<z.ZodObject<{
-        origin: z.ZodString;
-        schemaRevision: z.ZodString;
-        schemaBundle: z.ZodString;
-        service: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"local">;
-            artifact: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"remote">;
-            etag: z.ZodString;
-        }, z.core.$strict>], "kind">;
-        capabilities: z.ZodObject<{
-            functions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            classes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                class: z.ZodObject<{
-                    origin: z.ZodString;
-                    kind: z.ZodLiteral<"class">;
-                    name: z.ZodString;
-                }, z.core.$strict>;
-                operations: z.ZodArray<z.ZodEnum<{
-                    create: "create";
-                    delete: "delete";
-                    read: "read";
-                    traverse: "traverse";
-                    update: "update";
-                }>>;
-            }, z.core.$strict>>>;
-            admin: z.ZodOptional<z.ZodObject<{
-                grant: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                    create: "create";
-                    delete: "delete";
-                    grant: "grant";
-                    read: "read";
-                    revoke: "revoke";
-                    traverse: "traverse";
-                    update: "update";
-                    use: "use";
-                }>>>;
-                revoke: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                    create: "create";
-                    delete: "delete";
-                    grant: "grant";
-                    read: "read";
-                    revoke: "revoke";
-                    traverse: "traverse";
-                    update: "update";
-                    use: "use";
-                }>>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-        dependencies: z.ZodArray<z.ZodObject<{
-            origin: z.ZodString;
-            installation: z.ZodString;
-            target: z.ZodString;
-            readinessReceipt: z.ZodString;
-            meaningComparison: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const readinessReceipt: z.ZodObject<{
-    installation: z.ZodString;
-    target: z.ZodString;
-    transition: z.ZodString;
-    dependencies: z.ZodArray<z.ZodObject<{
-        origin: z.ZodString;
-        installation: z.ZodString;
-        target: z.ZodString;
-        readinessReceipt: z.ZodString;
-        meaningComparison: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const transitionReceipt: z.ZodObject<{
-    intent: z.ZodObject<{
-        transition: z.ZodString;
-        operation: z.ZodString;
-        installation: z.ZodString;
-        origin: z.ZodString;
-        source: z.ZodNullable<z.ZodObject<{
-            origin: z.ZodString;
-            schemaRevision: z.ZodString;
-            schemaBundle: z.ZodString;
-            service: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"local">;
-                artifact: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"remote">;
-                etag: z.ZodString;
-            }, z.core.$strict>], "kind">;
-            capabilities: z.ZodObject<{
-                functions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                classes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    class: z.ZodObject<{
-                        origin: z.ZodString;
-                        kind: z.ZodLiteral<"class">;
-                        name: z.ZodString;
-                    }, z.core.$strict>;
-                    operations: z.ZodArray<z.ZodEnum<{
-                        create: "create";
-                        delete: "delete";
-                        read: "read";
-                        traverse: "traverse";
-                        update: "update";
-                    }>>;
-                }, z.core.$strict>>>;
-                admin: z.ZodOptional<z.ZodObject<{
-                    grant: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                        create: "create";
-                        delete: "delete";
-                        grant: "grant";
-                        read: "read";
-                        revoke: "revoke";
-                        traverse: "traverse";
-                        update: "update";
-                        use: "use";
-                    }>>>;
-                    revoke: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                        create: "create";
-                        delete: "delete";
-                        grant: "grant";
-                        read: "read";
-                        revoke: "revoke";
-                        traverse: "traverse";
-                        update: "update";
-                        use: "use";
-                    }>>>;
-                }, z.core.$strict>>;
-            }, z.core.$strict>;
-            dependencies: z.ZodArray<z.ZodObject<{
-                origin: z.ZodString;
-                installation: z.ZodString;
-                target: z.ZodString;
-                readinessReceipt: z.ZodString;
-                meaningComparison: z.ZodString;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-        target: z.ZodNullable<z.ZodObject<{
-            origin: z.ZodString;
-            schemaRevision: z.ZodString;
-            schemaBundle: z.ZodString;
-            service: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"local">;
-                artifact: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"remote">;
-                etag: z.ZodString;
-            }, z.core.$strict>], "kind">;
-            capabilities: z.ZodObject<{
-                functions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                classes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    class: z.ZodObject<{
-                        origin: z.ZodString;
-                        kind: z.ZodLiteral<"class">;
-                        name: z.ZodString;
-                    }, z.core.$strict>;
-                    operations: z.ZodArray<z.ZodEnum<{
-                        create: "create";
-                        delete: "delete";
-                        read: "read";
-                        traverse: "traverse";
-                        update: "update";
-                    }>>;
-                }, z.core.$strict>>>;
-                admin: z.ZodOptional<z.ZodObject<{
-                    grant: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                        create: "create";
-                        delete: "delete";
-                        grant: "grant";
-                        read: "read";
-                        revoke: "revoke";
-                        traverse: "traverse";
-                        update: "update";
-                        use: "use";
-                    }>>>;
-                    revoke: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                        create: "create";
-                        delete: "delete";
-                        grant: "grant";
-                        read: "read";
-                        revoke: "revoke";
-                        traverse: "traverse";
-                        update: "update";
-                        use: "use";
-                    }>>>;
-                }, z.core.$strict>>;
-            }, z.core.$strict>;
-            dependencies: z.ZodArray<z.ZodObject<{
-                origin: z.ZodString;
-                installation: z.ZodString;
-                target: z.ZodString;
-                readinessReceipt: z.ZodString;
-                meaningComparison: z.ZodString;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-    phase: z.ZodEnum<{
+            }>;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>;
+    phase: import("zod").ZodEnum<{
         converge: "converge";
         cutover: "cutover";
     }>;
-    state: z.ZodLiteral<"committed">;
-    readiness: z.ZodOptional<z.ZodObject<{
-        installation: z.ZodString;
-        target: z.ZodString;
-        transition: z.ZodString;
-        dependencies: z.ZodArray<z.ZodObject<{
-            origin: z.ZodString;
-            installation: z.ZodString;
-            target: z.ZodString;
-            readinessReceipt: z.ZodString;
-            meaningComparison: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
+    state: import("zod").ZodLiteral<"committed">;
+    readiness: import("zod").ZodOptional<import("zod").ZodObject<{
+        generation: import("zod").ZodString;
+        transition: import("zod").ZodString;
+        dependencies: import("zod").ZodArray<import("zod").ZodObject<{
+            origin: import("zod").ZodString;
+            generation: import("zod").ZodString;
+            readiness: import("zod").ZodString;
+            meaning: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>>;
+    }, import("zod/v4/core").$strict>>;
+}, import("zod/v4/core").$strict>;

package/dist/schema/kernel/syscalls/contracts/installation.js

@@ -1,87 +1,49 @@
 import { fullMatch } from '@astrale-os/kernel-dsl/v1/value/full-match';
-import { z } from 'zod';
+import { array, enum as enumeration, literal, number, strictObject, string } from 'zod';
 import { operationIdSchema } from '../../../installation/operation-id.js';
 export { operationIdSchema };
-export const installationText = z.string().min(1);
+export const installationText = string().min(1);
 export const installationDigest = installationText.check(fullMatch('sha256:[0-9a-f]{64}'));
-export const artifactRef = z.strictObject({
+export const artifactRef = strictObject({
     digest: installationDigest,
     mediaType: installationText,
-    size: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    size: number().int().min(0).max(Number.MAX_SAFE_INTEGER),
 });
-export const dependencyReadinessCoordinate = z.strictObject({
+const dependencyReadinessEvidence = strictObject({
     origin: installationText,
-    installation: installationText,
-    target: installationDigest,
-    readinessReceipt: installationDigest,
-    meaningComparison: installationDigest,
+    generation: installationDigest,
+    readiness: installationDigest,
+    meaning: installationDigest,
 });
-export const serviceTarget = z.discriminatedUnion('kind', [
-    z.strictObject({
-        kind: z.literal('local'),
-        artifact: installationDigest,
-    }),
-    z.strictObject({
-        kind: z.literal('remote'),
-        etag: installationDigest,
-    }),
-]);
-const authorityOperation = z.enum([
-    'use',
-    'create',
-    'read',
-    'traverse',
-    'update',
-    'delete',
-    'grant',
-    'revoke',
-]);
-const classOperation = z.enum(['create', 'read', 'traverse', 'update', 'delete']);
-const capabilityRequirements = z.strictObject({
-    functions: z.array(installationText).min(1).optional(),
-    classes: z
-        .array(z.strictObject({
-        class: z.strictObject({
-            origin: installationText,
-            kind: z.literal('class'),
-            name: installationText,
-        }),
-        operations: z.array(classOperation).min(1),
-    }))
-        .min(1)
-        .optional(),
-    admin: z
-        .strictObject({
-        grant: z.array(authorityOperation).min(1).optional(),
-        revoke: z.array(authorityOperation).min(1).optional(),
-    })
-        .optional(),
-});
-export const installationTarget = z.strictObject({
+const domainGeneration = strictObject({
     origin: installationText,
-    schemaRevision: installationText,
-    schemaBundle: installationDigest,
-    service: serviceTarget,
-    capabilities: capabilityRequirements,
-    dependencies: z.array(dependencyReadinessCoordinate),
+    revision: installationText,
+    generation: installationDigest,
+});
+const consentIssuers = strictObject({ from: installationText, to: installationText });
+export const issuerConsent = strictObject({
+    issuer: consentIssuers,
+    previous: enumeration(['drain', 'revoke']).optional(),
 });
-export const transitionIntent = z.strictObject({
+const transitionIntent = strictObject({
     transition: installationText,
     operation: operationIdSchema,
-    installation: installationText,
     origin: installationText,
-    source: installationTarget.nullable(),
-    target: installationTarget.nullable(),
+    previous: domainGeneration.nullable(),
+    generation: domainGeneration.nullable(),
+    consent: strictObject({
+        issuer: consentIssuers,
+        previous: enumeration(['drain', 'revoke']),
+    }).optional(),
 });
-export const readinessReceipt = z.strictObject({
-    installation: installationText,
-    target: installationDigest,
+export const readinessReceipt = strictObject({
+    generation: installationDigest,
     transition: installationText,
-    dependencies: z.array(dependencyReadinessCoordinate),
+    dependencies: array(dependencyReadinessEvidence),
 });
-export const transitionReceipt = z.strictObject({
+export const transitionReceipt = strictObject({
     intent: transitionIntent,
-    phase: z.enum(['cutover', 'converge']),
-    state: z.literal('committed'),
+    phase: enumeration(['cutover', 'converge']),
+    state: literal('committed'),
     readiness: readinessReceipt.optional(),
 });

package/dist/schema/kernel/syscalls/contracts/introspect.d.ts

@@ -1,15 +1,11 @@
-import { z } from 'zod';
-export declare const introspectInput: z.ZodObject<{
-    from: z.ZodObject<{
-        kind: z.ZodLiteral<"installation">;
-        origin: z.ZodString;
-    }, z.core.$strict>;
-    select: z.ZodObject<{
-        state: z.ZodOptional<z.ZodLiteral<true>>;
-        target: z.ZodOptional<z.ZodLiteral<true>>;
-        source: z.ZodOptional<z.ZodLiteral<true>>;
-        bundle: z.ZodOptional<z.ZodLiteral<true>>;
-        readiness: z.ZodOptional<z.ZodLiteral<true>>;
-        capabilities: z.ZodOptional<z.ZodLiteral<true>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
+/** One ready Domain by origin, or the installed listing, which names no origin. */
+export declare const introspectInput: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+    kind: import("zod").ZodEnum<{
+        bundle: "bundle";
+        dependencies: "dependencies";
+        inspect: "inspect";
+    }>;
+    origin: import("zod").ZodString;
+}, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+    kind: import("zod").ZodLiteral<"installed">;
+}, import("zod/v4/core").$strict>]>;

package/dist/schema/kernel/syscalls/contracts/introspect.js

@@ -1,16 +1,9 @@
-import { z } from 'zod';
-const selection = z.strictObject({
-    state: z.literal(true).optional(),
-    target: z.literal(true).optional(),
-    source: z.literal(true).optional(),
-    bundle: z.literal(true).optional(),
-    readiness: z.literal(true).optional(),
-    capabilities: z.literal(true).optional(),
-});
-export const introspectInput = z.strictObject({
-    from: z.strictObject({
-        kind: z.literal('installation'),
-        origin: z.string().min(1),
+import { enum as enumeration, literal, strictObject, string, union } from 'zod';
+/** One ready Domain by origin, or the installed listing, which names no origin. */
+export const introspectInput = union([
+    strictObject({
+        kind: enumeration(['inspect', 'bundle', 'dependencies']),
+        origin: string().min(1),
     }),
-    select: selection,
-});
+    strictObject({ kind: literal('installed') }),
+]);

package/dist/schema/kernel/syscalls/contracts/journal.d.ts

@@ -1,27 +1,26 @@
-import { z } from 'zod';
-export declare const journalInput: z.ZodObject<{
-    invocation: z.ZodOptional<z.ZodObject<{
-        source: z.ZodString;
-        id: z.ZodString;
-    }, z.core.$strict>>;
-    topics: z.ZodOptional<z.ZodObject<{
-        exact: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        prefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>;
-    principal: z.ZodOptional<z.ZodString>;
-    since: z.ZodOptional<z.ZodString>;
-    until: z.ZodOptional<z.ZodString>;
-    cursor: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-export declare const journalOutput: z.ZodObject<{
-    records: z.ZodArray<z.ZodUnknown>;
-    frontier: z.ZodObject<{
-        id: z.ZodString;
-        first: z.ZodOptional<z.ZodNumber>;
-        committed: z.ZodNumber;
-        durable: z.ZodNumber;
-    }, z.core.$strict>;
-    cursor: z.ZodOptional<z.ZodString>;
-    gap: z.ZodOptional<z.ZodUnknown>;
-}, z.core.$strict>;
+export declare const journalInput: import("zod").ZodObject<{
+    invocation: import("zod").ZodOptional<import("zod").ZodObject<{
+        source: import("zod").ZodString;
+        id: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>>;
+    topics: import("zod").ZodOptional<import("zod").ZodObject<{
+        exact: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        prefixes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strict>>;
+    principal: import("zod").ZodOptional<import("zod").ZodString>;
+    since: import("zod").ZodOptional<import("zod").ZodString>;
+    until: import("zod").ZodOptional<import("zod").ZodString>;
+    cursor: import("zod").ZodOptional<import("zod").ZodString>;
+    limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strict>;
+export declare const journalOutput: import("zod").ZodObject<{
+    records: import("zod").ZodArray<import("zod").ZodUnknown>;
+    frontier: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        first: import("zod").ZodOptional<import("zod").ZodNumber>;
+        committed: import("zod").ZodNumber;
+        durable: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strict>;
+    cursor: import("zod").ZodOptional<import("zod").ZodString>;
+    gap: import("zod").ZodOptional<import("zod").ZodUnknown>;
+}, import("zod/v4/core").$strict>;