@oomol-lab/open-flow 0.1.0-beta.78 → 0.1.0-beta.79

package/dist/common/control-api-conformance.js

@@ -8628,13 +8628,24 @@ var httpRequestConfigSchema = strictObject({
 	statusPolicy: _enum(["success", "all"]).default("success")
 });
 var httpRequestExecutorSchema = httpRequestConfigSchema.extend({ kind: literal("http-request") });
+//#endregion
+//#region src/state/common/state.ts
+var stateReadLimits = {
+	maxKeys: 16,
+	maxBytes: 1048576
+};
+var keySchema = string$1().min(1).refine((value) => new TextEncoder().encode(value).length <= 256);
+strictObject({
+	scope: _enum(["draft", "live"]),
+	values: literal(false).optional()
+});
 strictObject({
 	scope: _enum(["draft", "live"]),
-	values: boolean().optional()
+	keys: array(keySchema).min(1).max(stateReadLimits.maxKeys).refine((keys) => new Set(keys).size === keys.length, "State keys must be distinct.")
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
-	key: string$1().min(1).refine((key) => new TextEncoder().encode(key).length <= 256).optional()
+	key: keySchema.optional()
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
@@ -8652,11 +8663,10 @@ var flowStateViewSchema = object({
 		maxIdentities: number().positive(),
 		maxRunWrites: number().positive()
 	}),
-	values: array(object({
+	values: array(strictObject({
 		key: string$1(),
 		size: number().nonnegative(),
-		updatedAt: number(),
-		value: json$4().optional()
+		updatedAt: number()
 	})),
 	spaces: array(object({
 		space: string$1(),
@@ -8666,6 +8676,17 @@ var flowStateViewSchema = object({
 		updatedAt: number()
 	}))
 });
+var flowStateValuesSchema = object({
+	version: literal(1),
+	scope: _enum(["draft", "live"]),
+	values: array(strictObject({
+		key: keySchema,
+		value: json$4()
+	})).min(1).max(stateReadLimits.maxKeys)
+}).refine((response) => {
+	const encoder = new TextEncoder();
+	return response.values.reduce((bytes, item) => bytes + (item.value === null ? 0 : encoder.encode(JSON.stringify(item.value)).byteLength), 0) <= stateReadLimits.maxBytes;
+}, "State values exceed the 1 MiB read limit.");
 function checkJsonDepth(value, depth = 0) {
 	if (depth > 64) throw new TypeError("Value exceeds the maximum JSON depth.");
 	if (value != null && typeof value == "object") for (const child of Object.values(value)) checkJsonDepth(child, depth + 1);
@@ -12171,10 +12192,22 @@ var ControlClient = class {
 			})
 		}));
 	}
-	async getFlowState(flowId, scope, values = false) {
-		const result = flowStateViewSchema.safeParse(await this.request(`/v1/flows/${segment(flowId)}/state?scope=${scope}&values=${values}`));
+	async getFlowState(flowId, scope) {
+		const result = flowStateViewSchema.safeParse(await this.request(`/v1/flows/${segment(flowId)}/state?scope=${scope}`));
 		return result.success && result.data.scope === scope ? result.data : invalidResponse();
 	}
+	async getFlowStateValues(flowId, scope, keys, signal) {
+		const result = flowStateValuesSchema.safeParse(await this.request(`/v1/flows/${segment(flowId)}/state/read`, {
+			method: "POST",
+			body: JSON.stringify({
+				version: 1,
+				scope,
+				keys
+			}),
+			signal
+		}));
+		return result.success && result.data.scope === scope && result.data.values.length === keys.length && result.data.values.every((item, index) => item.key === keys[index]) ? result.data : invalidResponse();
+	}
 	async clearFlowState(flowId, scope, key) {
 		const source = record$1(await this.request(`/v1/flows/${segment(flowId)}/state?scope=${scope}${key == null ? "" : `&key=${encodeURIComponent(key)}`}`, { method: "DELETE" }));
 		if (source.version !== 1 || source.cleared !== true) invalidResponse();
@@ -12866,6 +12899,46 @@ function liveRunRequest(harness, publicationId, key) {
 	});
 }
 var controlApiConformanceCases = [
+	{
+		name: "reads State metadata and bounded explicit keys without scope-wide value retrieval",
+		async verify(harness) {
+			const api = new ControlClient((url, init) => harness.request(new Request(new URL(url, harness.origin), init)));
+			const flow = await api.createFlow("State reads");
+			equal((await api.getFlowState(flow.flowId, "draft")).values, [], "New Flow State metadata");
+			equal(await api.getFlowStateValues(flow.flowId, "live", ["second", "first"]), {
+				version: 1,
+				scope: "live",
+				values: [{
+					key: "second",
+					value: null
+				}, {
+					key: "first",
+					value: null
+				}]
+			}, "Missing named State keys");
+			const metadata = await request(harness, `/v1/flows/${flow.flowId}/state?scope=draft&values=false`);
+			await json(metadata, 200, "Legacy metadata-only query");
+			equal(metadata.headers.get("cache-control"), "no-store", "State metadata cache policy");
+			await error(await request(harness, `/v1/flows/${flow.flowId}/state?scope=draft&values=true`), 400, "flow.invalid", "Scope-wide State values");
+			for (const input of [
+				{
+					scope: "draft",
+					keys: []
+				},
+				{ keys: ["key"] },
+				{
+					scope: "draft",
+					keys: Array.from({ length: 17 }, (_, index) => String(index))
+				}
+			]) await error(await request(harness, `/v1/flows/${flow.flowId}/state/read`, {
+				method: "POST",
+				body: JSON.stringify({
+					version: 1,
+					...input
+				})
+			}), 400, "flow.invalid", "Invalid named State read");
+		}
+	},
 	{
 		name: "imports workflow files atomically and exports a new unpublished draft with its Presentation",
 		async verify(harness) {

package/dist/common/control-api.d.ts

@@ -1,5 +1,5 @@
 import type { CanvasCommand } from './canvas-commands.js';
-import type { FlowStateView, StateScope } from './flow-state.js';
+import type { FlowStateValues, FlowStateView, StateScope } from './flow-state.js';
 export type { CanvasCommand, CanvasCommandSubscriber } from './canvas-commands.js';
 import type { LiveDetails } from './liveDetails.js';
 export { liveEntries } from './liveDetails.js';
@@ -847,7 +847,8 @@ export declare class ControlClient {
     deleteTag(tagId: string): Promise<void>;
     setFlowTags(flowId: string, tagIds: readonly string[]): Promise<Flow>;
     updateFlow(flowId: string, changes: FlowUpdate): Promise<Flow>;
-    getFlowState(flowId: string, scope: StateScope, values?: boolean): Promise<FlowStateView>;
+    getFlowState(flowId: string, scope: StateScope): Promise<FlowStateView>;
+    getFlowStateValues(flowId: string, scope: StateScope, keys: readonly string[], signal?: AbortSignal): Promise<FlowStateValues>;
     clearFlowState(flowId: string, scope: StateScope, key?: string): Promise<void>;
     clearFlowDedupe(flowId: string, scope: StateScope, space: string): Promise<void>;
     renameFlow(flowId: string, name: string): Promise<Flow>;

package/dist/common/control-api.js

@@ -5773,13 +5773,24 @@ function dequal(foo, bar) {
 	}
 	return foo !== foo && bar !== bar;
 }
+//#endregion
+//#region src/state/common/state.ts
+var stateReadLimits = {
+	maxKeys: 16,
+	maxBytes: 1048576
+};
+var keySchema = string$1().min(1).refine((value) => new TextEncoder().encode(value).length <= 256);
+strictObject({
+	scope: _enum(["draft", "live"]),
+	values: literal(false).optional()
+});
 strictObject({
 	scope: _enum(["draft", "live"]),
-	values: boolean().optional()
+	keys: array(keySchema).min(1).max(stateReadLimits.maxKeys).refine((keys) => new Set(keys).size === keys.length, "State keys must be distinct.")
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
-	key: string$1().min(1).refine((key) => new TextEncoder().encode(key).length <= 256).optional()
+	key: keySchema.optional()
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
@@ -5797,11 +5808,10 @@ var flowStateViewSchema = object({
 		maxIdentities: number().positive(),
 		maxRunWrites: number().positive()
 	}),
-	values: array(object({
+	values: array(strictObject({
 		key: string$1(),
 		size: number().nonnegative(),
-		updatedAt: number(),
-		value: json$3().optional()
+		updatedAt: number()
 	})),
 	spaces: array(object({
 		space: string$1(),
@@ -5811,6 +5821,17 @@ var flowStateViewSchema = object({
 		updatedAt: number()
 	}))
 });
+var flowStateValuesSchema = object({
+	version: literal(1),
+	scope: _enum(["draft", "live"]),
+	values: array(strictObject({
+		key: keySchema,
+		value: json$3()
+	})).min(1).max(stateReadLimits.maxKeys)
+}).refine((response) => {
+	const encoder = new TextEncoder();
+	return response.values.reduce((bytes, item) => bytes + (item.value === null ? 0 : encoder.encode(JSON.stringify(item.value)).byteLength), 0) <= stateReadLimits.maxBytes;
+}, "State values exceed the 1 MiB read limit.");
 //#endregion
 //#region src/json-schema-subset/utils.ts
 var nextId = 0;
@@ -12862,10 +12883,22 @@ var ControlClient = class {
 			})
 		}));
 	}
-	async getFlowState(flowId, scope, values = false) {
-		const result = flowStateViewSchema.safeParse(await this.request(`/v1/flows/${segment(flowId)}/state?scope=${scope}&values=${values}`));
+	async getFlowState(flowId, scope) {
+		const result = flowStateViewSchema.safeParse(await this.request(`/v1/flows/${segment(flowId)}/state?scope=${scope}`));
 		return result.success && result.data.scope === scope ? result.data : invalidResponse();
 	}
+	async getFlowStateValues(flowId, scope, keys, signal) {
+		const result = flowStateValuesSchema.safeParse(await this.request(`/v1/flows/${segment(flowId)}/state/read`, {
+			method: "POST",
+			body: JSON.stringify({
+				version: 1,
+				scope,
+				keys
+			}),
+			signal
+		}));
+		return result.success && result.data.scope === scope && result.data.values.length === keys.length && result.data.values.every((item, index) => item.key === keys[index]) ? result.data : invalidResponse();
+	}
 	async clearFlowState(flowId, scope, key) {
 		const source = record(await this.request(`/v1/flows/${segment(flowId)}/state?scope=${scope}${key == null ? "" : `&key=${encodeURIComponent(key)}`}`, { method: "DELETE" }));
 		if (source.version !== 1 || source.cleared !== true) invalidResponse();

package/dist/common/control-requests.d.ts

@@ -10,6 +10,11 @@ export declare const waitActionBodySchema: {
     };
 };
 export declare const controlRequests: {
+    readFlowState: (value: unknown) => {
+        scope: "draft" | "live";
+        keys: string[];
+        version: 1;
+    };
     canvas: (value: unknown) => {
         command: {
             type: "focus";

package/dist/common/control-requests.js

@@ -12473,13 +12473,24 @@ function httpRequestInputs(mappings, previous, next) {
 	const rename = candidate != null && ["query.", "header."].some((prefix) => candidate.every((name) => name.startsWith(prefix))) ? candidate : void 0;
 	return remapInputMappings(mappings, next.inputs, rename);
 }
+//#endregion
+//#region src/state/common/state.ts
+var stateReadLimits = {
+	maxKeys: 16,
+	maxBytes: 1048576
+};
+var keySchema = string().min(1).refine((value) => new TextEncoder().encode(value).length <= 256);
 strictObject({
 	scope: _enum(["draft", "live"]),
-	values: boolean().optional()
+	values: literal(false).optional()
+});
+var stateReadSchema = strictObject({
+	scope: _enum(["draft", "live"]),
+	keys: array(keySchema).min(1).max(stateReadLimits.maxKeys).refine((keys) => new Set(keys).size === keys.length, "State keys must be distinct.")
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
-	key: string().min(1).refine((key) => new TextEncoder().encode(key).length <= 256).optional()
+	key: keySchema.optional()
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
@@ -12516,11 +12527,10 @@ object$1({
 		maxIdentities: number().positive(),
 		maxRunWrites: number().positive()
 	}),
-	values: array(object$1({
+	values: array(strictObject({
 		key: string(),
 		size: number().nonnegative(),
-		updatedAt: number(),
-		value: json$5().optional()
+		updatedAt: number()
 	})),
 	spaces: array(object$1({
 		space: string(),
@@ -12530,6 +12540,17 @@ object$1({
 		updatedAt: number()
 	}))
 });
+object$1({
+	version: literal(1),
+	scope: _enum(["draft", "live"]),
+	values: array(strictObject({
+		key: keySchema,
+		value: json$5()
+	})).min(1).max(stateReadLimits.maxKeys)
+}).refine((response) => {
+	const encoder = new TextEncoder();
+	return response.values.reduce((bytes, item) => bytes + (item.value === null ? 0 : encoder.encode(JSON.stringify(item.value)).byteLength), 0) <= stateReadLimits.maxBytes;
+}, "State values exceed the 1 MiB read limit.");
 function checkJsonDepth(value, depth = 0) {
 	if (depth > 64) throw new TypeError("Value exceeds the maximum JSON depth.");
 	if (value != null && typeof value == "object") for (const child of Object.values(value)) checkJsonDepth(child, depth + 1);
@@ -17868,6 +17889,7 @@ var trigger = strictObject({
 	outputs: record$3(string(), json)
 });
 var schemas = {
+	readFlowState: stateReadSchema.extend({ version }),
 	canvas: strictObject({
 		command: canvasCommandSchema,
 		version
@@ -18007,6 +18029,7 @@ function decoder(schema) {
 	return (value) => schema.parse(value);
 }
 var controlRequests = {
+	readFlowState: decoder(schemas.readFlowState),
 	canvas: decoder(schemas.canvas),
 	authoringCheck: decoder(schemas.authoringCheck),
 	authoringEdit: decoder(schemas.authoringEdit),

package/dist/common/flow-authoring.js

@@ -8760,13 +8760,24 @@ var httpRequestExecutorSchema = strictObject({
 	]).default("auto"),
 	statusPolicy: _enum(["success", "all"]).default("success")
 }).extend({ kind: literal("http-request") });
+//#endregion
+//#region src/state/common/state.ts
+var stateReadLimits = {
+	maxKeys: 16,
+	maxBytes: 1048576
+};
+var keySchema = string().min(1).refine((value) => new TextEncoder().encode(value).length <= 256);
+strictObject({
+	scope: _enum(["draft", "live"]),
+	values: literal(false).optional()
+});
 strictObject({
 	scope: _enum(["draft", "live"]),
-	values: boolean().optional()
+	keys: array(keySchema).min(1).max(stateReadLimits.maxKeys).refine((keys) => new Set(keys).size === keys.length, "State keys must be distinct.")
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
-	key: string().min(1).refine((key) => new TextEncoder().encode(key).length <= 256).optional()
+	key: keySchema.optional()
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
@@ -8783,11 +8794,10 @@ object({
 		maxIdentities: number().positive(),
 		maxRunWrites: number().positive()
 	}),
-	values: array(object({
+	values: array(strictObject({
 		key: string(),
 		size: number().nonnegative(),
-		updatedAt: number(),
-		value: json$1().optional()
+		updatedAt: number()
 	})),
 	spaces: array(object({
 		space: string(),
@@ -8797,6 +8807,17 @@ object({
 		updatedAt: number()
 	}))
 });
+object({
+	version: literal(1),
+	scope: _enum(["draft", "live"]),
+	values: array(strictObject({
+		key: keySchema,
+		value: json$1()
+	})).min(1).max(stateReadLimits.maxKeys)
+}).refine((response) => {
+	const encoder = new TextEncoder();
+	return response.values.reduce((bytes, item) => bytes + (item.value === null ? 0 : encoder.encode(JSON.stringify(item.value)).byteLength), 0) <= stateReadLimits.maxBytes;
+}, "State values exceed the 1 MiB read limit.");
 function checkJsonDepth(value, depth = 0) {
 	if (depth > 64) throw new TypeError("Value exceeds the maximum JSON depth.");
 	if (value != null && typeof value == "object") for (const child of Object.values(value)) checkJsonDepth(child, depth + 1);

package/dist/common/flow-change.js

@@ -8833,13 +8833,24 @@ var httpRequestExecutorSchema = strictObject({
 	]).default("auto"),
 	statusPolicy: _enum(["success", "all"]).default("success")
 }).extend({ kind: literal("http-request") });
+//#endregion
+//#region src/state/common/state.ts
+var stateReadLimits = {
+	maxKeys: 16,
+	maxBytes: 1048576
+};
+var keySchema = string().min(1).refine((value) => new TextEncoder().encode(value).length <= 256);
+strictObject({
+	scope: _enum(["draft", "live"]),
+	values: literal(false).optional()
+});
 strictObject({
 	scope: _enum(["draft", "live"]),
-	values: boolean().optional()
+	keys: array(keySchema).min(1).max(stateReadLimits.maxKeys).refine((keys) => new Set(keys).size === keys.length, "State keys must be distinct.")
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
-	key: string().min(1).refine((key) => new TextEncoder().encode(key).length <= 256).optional()
+	key: keySchema.optional()
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
@@ -8856,11 +8867,10 @@ object({
 		maxIdentities: number().positive(),
 		maxRunWrites: number().positive()
 	}),
-	values: array(object({
+	values: array(strictObject({
 		key: string(),
 		size: number().nonnegative(),
-		updatedAt: number(),
-		value: json$1().optional()
+		updatedAt: number()
 	})),
 	spaces: array(object({
 		space: string(),
@@ -8870,6 +8880,17 @@ object({
 		updatedAt: number()
 	}))
 });
+object({
+	version: literal(1),
+	scope: _enum(["draft", "live"]),
+	values: array(strictObject({
+		key: keySchema,
+		value: json$1()
+	})).min(1).max(stateReadLimits.maxKeys)
+}).refine((response) => {
+	const encoder = new TextEncoder();
+	return response.values.reduce((bytes, item) => bytes + (item.value === null ? 0 : encoder.encode(JSON.stringify(item.value)).byteLength), 0) <= stateReadLimits.maxBytes;
+}, "State values exceed the 1 MiB read limit.");
 function checkJsonDepth(value, depth = 0) {
 	if (depth > 64) throw new TypeError("Value exceeds the maximum JSON depth.");
 	if (value != null && typeof value == "object") for (const child of Object.values(value)) checkJsonDepth(child, depth + 1);

package/dist/common/flow-encoding.js

@@ -8604,13 +8604,24 @@ var httpRequestExecutorSchema = strictObject({
 	]).default("auto"),
 	statusPolicy: _enum(["success", "all"]).default("success")
 }).extend({ kind: literal("http-request") });
+//#endregion
+//#region src/state/common/state.ts
+var stateReadLimits = {
+	maxKeys: 16,
+	maxBytes: 1048576
+};
+var keySchema = string().min(1).refine((value) => new TextEncoder().encode(value).length <= 256);
+strictObject({
+	scope: _enum(["draft", "live"]),
+	values: literal(false).optional()
+});
 strictObject({
 	scope: _enum(["draft", "live"]),
-	values: boolean().optional()
+	keys: array(keySchema).min(1).max(stateReadLimits.maxKeys).refine((keys) => new Set(keys).size === keys.length, "State keys must be distinct.")
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
-	key: string().min(1).refine((key) => new TextEncoder().encode(key).length <= 256).optional()
+	key: keySchema.optional()
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
@@ -8627,11 +8638,10 @@ object({
 		maxIdentities: number().positive(),
 		maxRunWrites: number().positive()
 	}),
-	values: array(object({
+	values: array(strictObject({
 		key: string(),
 		size: number().nonnegative(),
-		updatedAt: number(),
-		value: json$1().optional()
+		updatedAt: number()
 	})),
 	spaces: array(object({
 		space: string(),
@@ -8641,6 +8651,17 @@ object({
 		updatedAt: number()
 	}))
 });
+object({
+	version: literal(1),
+	scope: _enum(["draft", "live"]),
+	values: array(strictObject({
+		key: keySchema,
+		value: json$1()
+	})).min(1).max(stateReadLimits.maxKeys)
+}).refine((response) => {
+	const encoder = new TextEncoder();
+	return response.values.reduce((bytes, item) => bytes + (item.value === null ? 0 : encoder.encode(JSON.stringify(item.value)).byteLength), 0) <= stateReadLimits.maxBytes;
+}, "State values exceed the 1 MiB read limit.");
 //#endregion
 //#region src/flow/common/json.ts
 var maxJsonDepth = 64;

package/dist/common/flow-semantics.js

@@ -10362,13 +10362,24 @@ function openApiFieldIssues(task) {
 function openApiIssues(task) {
 	return openApiFieldIssues(task).map((issue) => issue.message);
 }
+//#endregion
+//#region src/state/common/state.ts
+var stateReadLimits = {
+	maxKeys: 16,
+	maxBytes: 1048576
+};
+var keySchema = string().min(1).refine((value) => new TextEncoder().encode(value).length <= 256);
+strictObject({
+	scope: _enum(["draft", "live"]),
+	values: literal(false).optional()
+});
 strictObject({
 	scope: _enum(["draft", "live"]),
-	values: boolean().optional()
+	keys: array(keySchema).min(1).max(stateReadLimits.maxKeys).refine((keys) => new Set(keys).size === keys.length, "State keys must be distinct.")
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
-	key: string().min(1).refine((key) => new TextEncoder().encode(key).length <= 256).optional()
+	key: keySchema.optional()
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
@@ -10405,11 +10416,10 @@ object$1({
 		maxIdentities: number().positive(),
 		maxRunWrites: number().positive()
 	}),
-	values: array(object$1({
+	values: array(strictObject({
 		key: string(),
 		size: number().nonnegative(),
-		updatedAt: number(),
-		value: json$1().optional()
+		updatedAt: number()
 	})),
 	spaces: array(object$1({
 		space: string(),
@@ -10419,6 +10429,17 @@ object$1({
 		updatedAt: number()
 	}))
 });
+object$1({
+	version: literal(1),
+	scope: _enum(["draft", "live"]),
+	values: array(strictObject({
+		key: keySchema,
+		value: json$1()
+	})).min(1).max(stateReadLimits.maxKeys)
+}).refine((response) => {
+	const encoder = new TextEncoder();
+	return response.values.reduce((bytes, item) => bytes + (item.value === null ? 0 : encoder.encode(JSON.stringify(item.value)).byteLength), 0) <= stateReadLimits.maxBytes;
+}, "State values exceed the 1 MiB read limit.");
 //#endregion
 //#region src/flow/common/inputValue.ts
 /** An explicit clear suppresses the default; absent mappings still inherit it. */

package/dist/common/flow-state.d.ts

@@ -2,13 +2,25 @@ import type { JsonValue, ManagedTaskDefinitionOf } from './flow-model.js';
 import { z } from 'zod';
 export { stateConformanceCases, type StateConformanceHarness } from './state-conformance.js';
 export type StateScope = 'draft' | 'live';
+export declare const stateReadLimits: {
+    maxKeys: number;
+    maxBytes: number;
+};
 export declare const stateQuerySchema: z.ZodObject<{
     scope: z.ZodEnum<{
         draft: "draft";
         live: "live";
     }>;
-    values: z.ZodOptional<z.ZodBoolean>;
+    values: z.ZodOptional<z.ZodLiteral<false>>;
 }, z.core.$strict>;
+export declare const stateReadSchema: z.ZodObject<{
+    scope: z.ZodEnum<{
+        draft: "draft";
+        live: "live";
+    }>;
+    keys: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type StateRead = z.infer<typeof stateReadSchema>;
 export declare const stateClearSchema: z.ZodObject<{
     scope: z.ZodEnum<{
         draft: "draft";
@@ -61,7 +73,6 @@ export interface FlowStateView {
         readonly key: string;
         readonly size: number;
         readonly updatedAt: number;
-        readonly value?: JsonValue;
     }[];
     readonly spaces: readonly {
         readonly space: string;
@@ -88,8 +99,7 @@ export declare const flowStateViewSchema: z.ZodObject<{
         key: z.ZodString;
         size: z.ZodNumber;
         updatedAt: z.ZodNumber;
-        value: z.ZodOptional<z.ZodJSONSchema>;
-    }, z.core.$strip>>;
+    }, z.core.$strict>>;
     spaces: z.ZodArray<z.ZodObject<{
         space: z.ZodString;
         count: z.ZodNumber;
@@ -98,3 +108,22 @@ export declare const flowStateViewSchema: z.ZodObject<{
         updatedAt: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+export interface FlowStateValues {
+    readonly version: 1;
+    readonly scope: StateScope;
+    readonly values: readonly {
+        readonly key: string;
+        readonly value: JsonValue;
+    }[];
+}
+export declare const flowStateValuesSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    scope: z.ZodEnum<{
+        draft: "draft";
+        live: "live";
+    }>;
+    values: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodJSONSchema;
+    }, z.core.$strict>>;
+}, z.core.$strip>;