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

package/dist/common/flow-change.js

@@ -8833,23 +8833,30 @@ 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"]),
 	space: string().regex(/^(flow|node:.+)$/)
 });
-var dedupeExecutorSchema = strictObject({
-	field: string().default(""),
-	mode: _enum(["new", "increasing"]).default("new"),
-	space: _enum(["node", "flow"]).default("node")
-}).extend({ kind: literal("dedupe") });
+var skipDuplicatesExecutorSchema = strictObject({ fields: array(string().refine((field) => field.length > 0 && field.split(".").every((part) => part.length > 0), "Use a nonempty dot-separated field path.")).refine((fields) => new Set(fields).size === fields.length, "Identity fields must be distinct.").default([]) }).extend({ kind: literal("skip-duplicates") });
 object({
 	version: literal(1),
 	scope: _enum(["draft", "live"]),
@@ -8860,24 +8867,30 @@ 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(),
-		mode: _enum(["new", "increasing"]),
 		count: number().nonnegative(),
-		watermark: union([
-			string(),
-			number(),
-			_null()
-		]),
+		pendingCount: number().nonnegative(),
+		reservedCount: number().nonnegative(),
 		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);
@@ -9177,7 +9190,7 @@ var managedFields = object({
 			revisionId: text
 		}),
 		httpRequestExecutorSchema,
-		dedupeExecutorSchema
+		skipDuplicatesExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -9673,7 +9686,7 @@ function changeOperationsSchema(kind) {
 	return toJSONSchema(schema, { io: "input" });
 }
 function checkModelVersion(content) {
-	if (content.modelVersion < 13 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind === "task" && "executor" in candidateNode.task && candidateNode.task.executor.kind === "dedupe")) throw new Error("Deduplication requires Flow model v13.");
+	if (content.modelVersion < 13 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind === "task" && "executor" in candidateNode.task && candidateNode.task.executor.kind === "skip-duplicates")) throw new Error("Skip Duplicates requires Flow model v13.");
 	if (content.modelVersion < 12 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && "moduleId" in candidateNode.task && candidateNode.task.capabilities?.some((item) => item.kind == "http"))) throw new TypeError("Code HTTP access requires Flow model version 12.");
 	if (content.modelVersion < 11 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && "executor" in candidateNode.task && candidateNode.task.executor.kind == "http-request")) throw new TypeError("HTTP Request requires Flow model version 11.");
 	if (content.modelVersion < 11 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && ("moduleId" in candidateNode.task ? candidateNode.task.capabilities?.some((item) => item.kind == "workflow") : candidateNode.task.executor.kind == "agent" && candidateNode.task.executor.tools.some((item) => item.kind == "workflow")))) throw new TypeError("Workflow tools require Flow model version 11.");
@@ -9772,7 +9785,7 @@ var nodeErrorSchema = {
 	}
 };
 function supportsNodeErrorHandling(node) {
-	return supportsNodeRetry(node) || node.kind === "task" && "executor" in node.task && node.task.executor.kind === "dedupe";
+	return supportsNodeRetry(node) || node.kind === "task" && "executor" in node.task && node.task.executor.kind === "skip-duplicates";
 }
 function nodeSystemOutputPorts(node) {
 	return supportsNodeErrorHandling(node) && node.onError == "error" ? { error: {

package/dist/common/flow-encoding.js

@@ -8604,23 +8604,30 @@ 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"]),
 	space: string().regex(/^(flow|node:.+)$/)
 });
-var dedupeExecutorSchema = strictObject({
-	field: string().default(""),
-	mode: _enum(["new", "increasing"]).default("new"),
-	space: _enum(["node", "flow"]).default("node")
-}).extend({ kind: literal("dedupe") });
+var skipDuplicatesExecutorSchema = strictObject({ fields: array(string().refine((field) => field.length > 0 && field.split(".").every((part) => part.length > 0), "Use a nonempty dot-separated field path.")).refine((fields) => new Set(fields).size === fields.length, "Identity fields must be distinct.").default([]) }).extend({ kind: literal("skip-duplicates") });
 object({
 	version: literal(1),
 	scope: _enum(["draft", "live"]),
@@ -8631,24 +8638,30 @@ 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(),
-		mode: _enum(["new", "increasing"]),
 		count: number().nonnegative(),
-		watermark: union([
-			string(),
-			number(),
-			_null()
-		]),
+		pendingCount: number().nonnegative(),
+		reservedCount: number().nonnegative(),
 		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;
@@ -8936,7 +8949,7 @@ var managedFields = object({
 			revisionId: text
 		}),
 		httpRequestExecutorSchema,
-		dedupeExecutorSchema
+		skipDuplicatesExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -9655,7 +9668,7 @@ array(union([...new Map(Object.entries(shapes).map(([kind, shape]) => [kind, sha
 	...shape
 })])).values()])).min(1);
 function checkModelVersion(content) {
-	if (content.modelVersion < 13 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind === "task" && "executor" in candidateNode.task && candidateNode.task.executor.kind === "dedupe")) throw new Error("Deduplication requires Flow model v13.");
+	if (content.modelVersion < 13 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind === "task" && "executor" in candidateNode.task && candidateNode.task.executor.kind === "skip-duplicates")) throw new Error("Skip Duplicates requires Flow model v13.");
 	if (content.modelVersion < 12 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && "moduleId" in candidateNode.task && candidateNode.task.capabilities?.some((item) => item.kind == "http"))) throw new TypeError("Code HTTP access requires Flow model version 12.");
 	if (content.modelVersion < 11 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && "executor" in candidateNode.task && candidateNode.task.executor.kind == "http-request")) throw new TypeError("HTTP Request requires Flow model version 11.");
 	if (content.modelVersion < 11 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && ("moduleId" in candidateNode.task ? candidateNode.task.capabilities?.some((item) => item.kind == "workflow") : candidateNode.task.executor.kind == "agent" && candidateNode.task.executor.tools.some((item) => item.kind == "workflow")))) throw new TypeError("Workflow tools require Flow model version 11.");

package/dist/common/flow-semantics.js

@@ -10362,30 +10362,37 @@ 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: boolean().optional()
+	values: literal(false).optional()
 });
 strictObject({
 	scope: _enum(["draft", "live"]),
-	key: string().min(1).refine((key) => new TextEncoder().encode(key).length <= 256).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"]),
-	space: string().regex(/^(flow|node:.+)$/)
+	key: keySchema.optional()
 });
-var dedupeConfigSchema = strictObject({
-	field: string().default(""),
-	mode: _enum(["new", "increasing"]).default("new"),
-	space: _enum(["node", "flow"]).default("node")
+strictObject({
+	scope: _enum(["draft", "live"]),
+	space: string().regex(/^(flow|node:.+)$/)
 });
-var dedupeExecutorSchema = dedupeConfigSchema.extend({ kind: literal("dedupe") });
-function dedupeTask(config = dedupeConfigSchema.parse({}), name = "Remove Duplicates") {
+var skipDuplicatesConfigSchema = strictObject({ fields: array(string().refine((field) => field.length > 0 && field.split(".").every((part) => part.length > 0), "Use a nonempty dot-separated field path.")).refine((fields) => new Set(fields).size === fields.length, "Identity fields must be distinct.").default([]) });
+var skipDuplicatesExecutorSchema = skipDuplicatesConfigSchema.extend({ kind: literal("skip-duplicates") });
+function skipDuplicatesTask(config = skipDuplicatesConfigSchema.parse({}), name = "Skip Duplicates") {
 	return {
 		name,
 		executor: {
 			...config,
-			kind: "dedupe"
+			kind: "skip-duplicates"
 		},
 		inputs: [{
 			handle: "items",
@@ -10409,24 +10416,30 @@ 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(),
-		mode: _enum(["new", "increasing"]),
 		count: number().nonnegative(),
-		watermark: union([
-			string(),
-			number(),
-			_null()
-		]),
+		pendingCount: number().nonnegative(),
+		reservedCount: number().nonnegative(),
 		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. */
@@ -10802,7 +10815,7 @@ var managedFields = object$1({
 			revisionId: text
 		}),
 		httpRequestExecutorSchema,
-		dedupeExecutorSchema
+		skipDuplicatesExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -11419,7 +11432,7 @@ var nodeErrorSchema = {
 	}
 };
 function supportsNodeErrorHandling(node) {
-	return supportsNodeRetry(node) || node.kind === "task" && "executor" in node.task && node.task.executor.kind === "dedupe";
+	return supportsNodeRetry(node) || node.kind === "task" && "executor" in node.task && node.task.executor.kind === "skip-duplicates";
 }
 function nodeSystemOutputPorts(node) {
 	return supportsNodeErrorHandling(node) && node.onError == "error" ? { error: {
@@ -25007,10 +25020,10 @@ async function validateFlow(revision, engine) {
 			message,
 			path: `/document/graph/nodes/${nodeId}/task/executor`
 		});
-		if (task.executor.kind === "dedupe") {
-			const expected = dedupeTask(task.executor);
+		if (task.executor.kind === "skip-duplicates") {
+			const expected = skipDuplicatesTask(task.executor);
 			if (!dequal(httpPortContracts(task.inputs), httpPortContracts(expected.inputs)) || !dequal(httpPortContracts(task.outputs), httpPortContracts(expected.outputs))) checked.diagnostics.push({
-				code: "dedupe.ports-invalid",
+				code: "skip-duplicates.ports-invalid",
 				column: 0,
 				line: 1,
 				message: "Deduplication ports must match the fixed contract.",
@@ -25151,7 +25164,7 @@ var httpPortContracts = (ports) => ports.filter((port) => "handle" in port).map(
 async function prepareFlow(revision, engineContract, triggerId) {
 	const engine = findEngineContract(engineContract);
 	if (engine == null) return { kind: "engine-unsupported" };
-	if (!engine.flowState && Object.values(revision.document.graph.nodes).some((node) => node.kind === "task" && "executor" in node.task && node.task.executor.kind === "dedupe")) return { kind: "engine-unsupported" };
+	if (!engine.flowState && Object.values(revision.document.graph.nodes).some((node) => node.kind === "task" && "executor" in node.task && node.task.executor.kind === "skip-duplicates")) return { kind: "engine-unsupported" };
 	if (!engine.httpRequests && Object.values(revision.document.graph.nodes).some((node) => node.kind == "task" && "executor" in node.task && node.task.executor.kind == "http-request")) return { kind: "engine-unsupported" };
 	if (!engine.codeFetch && Object.values(revision.document.graph.nodes).some((node) => node.kind == "task" && "moduleId" in node.task && node.task.capabilities?.some((item) => item.kind == "http"))) return { kind: "engine-unsupported" };
 	if (!engine.workflowTools && Object.values(revision.document.graph.nodes).some((node) => nodeWorkflowReferences(node).some((ref) => ref.tool != null))) return { kind: "engine-unsupported" };
@@ -25200,11 +25213,13 @@ async function prepareFlow(revision, engineContract, triggerId) {
 }
 function createRuntimeProgram(prepared, entryModuleId, engineDigest) {
 	if (!Object.hasOwn(prepared.modules, entryModuleId)) return;
+	const modules = /* @__PURE__ */ new Set([entryModuleId]);
+	for (const id of modules) for (const imported of prepared.modules[id].imports) modules.add(imported);
 	return {
 		engineContract: prepared.engineContract,
 		engineDigest,
 		entryModuleId,
-		modules: prepared.modules
+		modules: Object.fromEntries([...modules].map((id) => [id, prepared.modules[id]]))
 	};
 }
 function agentActions(flow) {

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";
@@ -24,49 +36,29 @@ export declare const dedupeClearSchema: z.ZodObject<{
     space: z.ZodString;
 }, z.core.$strict>;
 export type DedupeIdentity = string | number;
-export declare const dedupeConfigSchema: z.ZodObject<{
-    field: z.ZodDefault<z.ZodString>;
-    mode: z.ZodDefault<z.ZodEnum<{
-        increasing: "increasing";
-        new: "new";
-    }>>;
-    space: z.ZodDefault<z.ZodEnum<{
-        flow: "flow";
-        node: "node";
-    }>>;
+export declare const skipDuplicatesConfigSchema: z.ZodObject<{
+    fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
-export type DedupeConfig = z.infer<typeof dedupeConfigSchema>;
-export interface DedupeExecutor extends DedupeConfig {
-    readonly kind: 'dedupe';
+export type SkipDuplicatesConfig = z.infer<typeof skipDuplicatesConfigSchema>;
+export interface SkipDuplicatesExecutor extends SkipDuplicatesConfig {
+    readonly kind: 'skip-duplicates';
 }
-export declare const dedupeExecutorSchema: z.ZodObject<{
-    field: z.ZodDefault<z.ZodString>;
-    mode: z.ZodDefault<z.ZodEnum<{
-        increasing: "increasing";
-        new: "new";
-    }>>;
-    space: z.ZodDefault<z.ZodEnum<{
-        flow: "flow";
-        node: "node";
-    }>>;
-    kind: z.ZodLiteral<"dedupe">;
+export declare const skipDuplicatesExecutorSchema: z.ZodObject<{
+    fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    kind: z.ZodLiteral<"skip-duplicates">;
 }, z.core.$strict>;
-export declare function dedupeTask(config?: DedupeConfig, name?: string): ManagedTaskDefinitionOf<DedupeExecutor>;
+export declare function skipDuplicatesTask(config?: SkipDuplicatesConfig, name?: string): ManagedTaskDefinitionOf<SkipDuplicatesExecutor>;
 export declare class StateError extends Error {
     readonly retryable = false;
     readonly catchable: boolean;
-    readonly code: 'capability.invalid' | 'capability.denied' | 'dedupe.full' | 'limit-exceeded';
+    readonly code: 'capability.invalid' | 'capability.denied' | 'dedupe.full' | 'limit-exceeded' | 'node.input-invalid';
     constructor(code: StateError['code'], message: string);
 }
 export declare function stateKey(key: unknown): string;
 export declare function dedupeIdentities(value: unknown): DedupeIdentity[];
 export declare function hashIdentities(ids: readonly DedupeIdentity[]): Promise<Uint8Array[]>;
-export declare function watermarkValue(id: DedupeIdentity): number;
-export declare function increasingIdentities(ids: readonly DedupeIdentity[], watermark: DedupeIdentity | null): {
-    inserted: boolean[];
-    watermark: DedupeIdentity | null;
-};
-export declare function itemIdentities(items: JsonValue, field: string): DedupeIdentity[];
+/** Canonical identities include the field definition and preserve scalar types. */
+export declare function skipDuplicatesIdentities(items: JsonValue, fields: readonly string[]): string[];
 export interface FlowStateView {
     readonly version: 1;
     readonly scope: StateScope;
@@ -81,13 +73,12 @@ export interface FlowStateView {
         readonly key: string;
         readonly size: number;
         readonly updatedAt: number;
-        readonly value?: JsonValue;
     }[];
     readonly spaces: readonly {
         readonly space: string;
-        readonly mode: 'new' | 'increasing';
         readonly count: number;
-        readonly watermark: DedupeIdentity | null;
+        readonly pendingCount: number;
+        readonly reservedCount: number;
         readonly updatedAt: number;
     }[];
 }
@@ -108,16 +99,31 @@ 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;
-        mode: z.ZodEnum<{
-            increasing: "increasing";
-            new: "new";
-        }>;
         count: z.ZodNumber;
-        watermark: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+        pendingCount: z.ZodNumber;
+        reservedCount: z.ZodNumber;
         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>;