spawnfile 0.1.13 → 0.1.14

package/dist/manifest/memorySchemas.d.ts

@@ -0,0 +1,245 @@
+import { z } from "zod";
+export declare const memoryStoreSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"sqlite">;
+    path: z.ZodOptional<z.ZodString>;
+    persistence: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            durable: "durable";
+            ephemeral: "ephemeral";
+        }>;
+        mount: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"json">;
+    path: z.ZodOptional<z.ZodString>;
+    persistence: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            durable: "durable";
+            ephemeral: "ephemeral";
+        }>;
+        mount: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"postgres">;
+    dsn_secret: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"memory">;
+}, z.core.$strict>], "kind">;
+declare const memoryIndexSchema: z.ZodObject<{
+    graph: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            entity_graph: "entity_graph";
+            temporal_kg: "temporal_kg";
+        }>>;
+    }, z.core.$strict>>;
+    lexical: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        engine: z.ZodOptional<z.ZodEnum<{
+            sqlite_fts: "sqlite_fts";
+            bm25: "bm25";
+        }>>;
+    }, z.core.$strict>>;
+    rerank: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, z.core.$strict>>;
+    vector: z.ZodOptional<z.ZodObject<{
+        base_url: z.ZodOptional<z.ZodString>;
+        dimensions: z.ZodOptional<z.ZodNumber>;
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        model: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodEnum<{
+            ollama: "ollama";
+        }>>;
+        timeout_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const memoryConsolidationSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        disabled: "disabled";
+        on_threshold: "on_threshold";
+        scheduled: "scheduled";
+    }>>>;
+    schedule: z.ZodOptional<z.ZodString>;
+    summarize_after_events: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare const memoryRetentionSchema: z.ZodObject<{
+    forgetting: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        manual: "manual";
+        decay: "decay";
+        ttl: "ttl";
+    }>>>;
+    ttl: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const memoryAccessSchema: z.ZodObject<{
+    members: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const memoryBankSchema: z.ZodObject<{
+    access: z.ZodOptional<z.ZodObject<{
+        members: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    consolidation: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            disabled: "disabled";
+            on_threshold: "on_threshold";
+            scheduled: "scheduled";
+        }>>>;
+        schedule: z.ZodOptional<z.ZodString>;
+        summarize_after_events: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    index: z.ZodOptional<z.ZodObject<{
+        graph: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                entity_graph: "entity_graph";
+                temporal_kg: "temporal_kg";
+            }>>;
+        }, z.core.$strict>>;
+        lexical: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            engine: z.ZodOptional<z.ZodEnum<{
+                sqlite_fts: "sqlite_fts";
+                bm25: "bm25";
+            }>>;
+        }, z.core.$strict>>;
+        rerank: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strict>>;
+        vector: z.ZodOptional<z.ZodObject<{
+            base_url: z.ZodOptional<z.ZodString>;
+            dimensions: z.ZodOptional<z.ZodNumber>;
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            model: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodEnum<{
+                ollama: "ollama";
+            }>>;
+            timeout_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    retention: z.ZodOptional<z.ZodObject<{
+        forgetting: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            manual: "manual";
+            decay: "decay";
+            ttl: "ttl";
+        }>>>;
+        ttl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    store: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"sqlite">;
+        path: z.ZodOptional<z.ZodString>;
+        persistence: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                durable: "durable";
+                ephemeral: "ephemeral";
+            }>;
+            mount: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"json">;
+        path: z.ZodOptional<z.ZodString>;
+        persistence: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                durable: "durable";
+                ephemeral: "ephemeral";
+            }>;
+            mount: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"postgres">;
+        dsn_secret: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"memory">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export declare const memoryBanksSchema: z.ZodArray<z.ZodObject<{
+    access: z.ZodOptional<z.ZodObject<{
+        members: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    consolidation: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            disabled: "disabled";
+            on_threshold: "on_threshold";
+            scheduled: "scheduled";
+        }>>>;
+        schedule: z.ZodOptional<z.ZodString>;
+        summarize_after_events: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    index: z.ZodOptional<z.ZodObject<{
+        graph: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                entity_graph: "entity_graph";
+                temporal_kg: "temporal_kg";
+            }>>;
+        }, z.core.$strict>>;
+        lexical: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            engine: z.ZodOptional<z.ZodEnum<{
+                sqlite_fts: "sqlite_fts";
+                bm25: "bm25";
+            }>>;
+        }, z.core.$strict>>;
+        rerank: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strict>>;
+        vector: z.ZodOptional<z.ZodObject<{
+            base_url: z.ZodOptional<z.ZodString>;
+            dimensions: z.ZodOptional<z.ZodNumber>;
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            model: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodEnum<{
+                ollama: "ollama";
+            }>>;
+            timeout_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    retention: z.ZodOptional<z.ZodObject<{
+        forgetting: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            manual: "manual";
+            decay: "decay";
+            ttl: "ttl";
+        }>>>;
+        ttl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    store: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"sqlite">;
+        path: z.ZodOptional<z.ZodString>;
+        persistence: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                durable: "durable";
+                ephemeral: "ephemeral";
+            }>;
+            mount: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"json">;
+        path: z.ZodOptional<z.ZodString>;
+        persistence: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                durable: "durable";
+                ephemeral: "ephemeral";
+            }>;
+            mount: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"postgres">;
+        dsn_secret: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"memory">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>>;
+export type MemoryAccess = z.infer<typeof memoryAccessSchema>;
+export type MemoryBank = z.infer<typeof memoryBankSchema>;
+export type MemoryConsolidation = z.infer<typeof memoryConsolidationSchema>;
+export type MemoryIndex = z.infer<typeof memoryIndexSchema>;
+export type MemoryRetention = z.infer<typeof memoryRetentionSchema>;
+export type MemoryStore = z.infer<typeof memoryStoreSchema>;
+export {};

package/dist/manifest/memorySchemas.js

@@ -0,0 +1,148 @@
+import { z } from "zod";
+const memoryIdPattern = /^[A-Za-z0-9_-]+$/u;
+const memoryIdSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .regex(memoryIdPattern, "memory id must match [A-Za-z0-9_-]+");
+const absolutePosixPathSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .refine((value) => value.startsWith("/"), {
+    message: "memory paths must be absolute POSIX paths"
+});
+const memoryStorePersistenceSchema = z
+    .object({
+    mode: z.enum(["durable", "ephemeral"]),
+    mount: absolutePosixPathSchema.optional(),
+    name: z.string().trim().min(1).optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.mode === "ephemeral" && (value.mount || value.name)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "ephemeral persistence must not declare mount or name"
+        });
+    }
+});
+const memoryStoreSqliteSchema = z
+    .object({
+    kind: z.literal("sqlite"),
+    path: absolutePosixPathSchema.optional(),
+    persistence: memoryStorePersistenceSchema.optional()
+})
+    .strict();
+const memoryStoreJsonSchema = z
+    .object({
+    kind: z.literal("json"),
+    path: absolutePosixPathSchema.optional(),
+    persistence: memoryStorePersistenceSchema.optional()
+})
+    .strict();
+const memoryStorePostgresSchema = z
+    .object({
+    kind: z.literal("postgres"),
+    dsn_secret: z.string().trim().min(1)
+})
+    .strict();
+const memoryStoreMemorySchema = z
+    .object({
+    kind: z.literal("memory")
+})
+    .strict();
+export const memoryStoreSchema = z.discriminatedUnion("kind", [
+    memoryStoreSqliteSchema,
+    memoryStoreJsonSchema,
+    memoryStorePostgresSchema,
+    memoryStoreMemorySchema
+]);
+const memoryVectorSchema = z
+    .object({
+    base_url: z.string().trim().min(1).optional(),
+    dimensions: z.number().int().positive().optional(),
+    enabled: z.boolean().optional().default(false),
+    model: z.string().trim().min(1).optional(),
+    provider: z.enum(["ollama"]).optional(),
+    timeout_ms: z.number().int().positive().optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.enabled && !value.model) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "memory vector index requires model"
+        });
+    }
+});
+const memoryIndexSchema = z
+    .object({
+    graph: z
+        .object({
+        enabled: z.boolean().optional().default(false),
+        kind: z.enum(["entity_graph", "temporal_kg"]).optional()
+    })
+        .strict()
+        .optional(),
+    lexical: z
+        .object({
+        enabled: z.boolean().optional().default(true),
+        engine: z.enum(["sqlite_fts", "bm25"]).optional()
+    })
+        .strict()
+        .optional(),
+    rerank: z
+        .object({
+        enabled: z.boolean().optional().default(false)
+    })
+        .strict()
+        .optional(),
+    vector: memoryVectorSchema.optional()
+})
+    .strict();
+const memoryConsolidationSchema = z
+    .object({
+    mode: z.enum(["disabled", "on_threshold", "scheduled"]).optional().default("disabled"),
+    schedule: z.string().trim().min(1).optional(),
+    summarize_after_events: z.number().int().positive().optional()
+})
+    .strict();
+const memoryRetentionSchema = z
+    .object({
+    forgetting: z.enum(["manual", "decay", "ttl"]).optional().default("manual"),
+    ttl: z.string().trim().min(1).optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.forgetting !== "ttl" && value.ttl) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "memory retention ttl is only valid when forgetting is ttl"
+        });
+    }
+});
+const memoryAccessSchema = z
+    .object({
+    members: z.array(z.string().trim().min(1)).optional()
+})
+    .strict();
+const memoryBankSchema = z
+    .object({
+    access: memoryAccessSchema.optional(),
+    consolidation: memoryConsolidationSchema.optional(),
+    id: memoryIdSchema,
+    index: memoryIndexSchema.optional(),
+    retention: memoryRetentionSchema.optional(),
+    store: memoryStoreSchema
+})
+    .strict();
+export const memoryBanksSchema = z.array(memoryBankSchema).superRefine((value, context) => {
+    const ids = value.map((entry) => entry.id);
+    if (new Set(ids).size !== ids.length) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "memory ids must be unique"
+        });
+    }
+});

package/dist/manifest/renderSpawnfile.js

@@ -1,5 +1,7 @@
 import YAML from "yaml";
+import { isReferencedMember } from "./schemas.js";
 import { orderTeamNetworks } from "./renderSpawnfileNetworks.js";
+import { orderSurfaces } from "./renderSpawnfileSurfaces.js";
 import { orderWorkspace } from "./renderSpawnfileWorkspace.js";
 const withDefinedEntries = (entries) => Object.fromEntries(entries.filter((entry) => entry[1] !== undefined));
 const hasEntries = (value) => Object.keys(value).length > 0;
@@ -12,126 +14,6 @@ const orderRuntimeBinding = (runtime) => {
         ["options", runtime.options]
     ]);
 };
-const orderDiscordSurface = (surface) => {
-    if (!surface) {
-        return undefined;
-    }
-    return withDefinedEntries([
-        ["access", orderDiscordSurfaceAccess(surface.access)],
-        ["bot_token_secret", surface.bot_token_secret],
-        ["identity", surface.identity]
-    ]);
-};
-const orderDiscordSurfaceAccess = (access) => {
-    if (!access) {
-        return undefined;
-    }
-    return withDefinedEntries([
-        ["mode", access.mode],
-        ["users", access.users],
-        ["guilds", access.guilds],
-        ["channels", access.channels]
-    ]);
-};
-const orderTelegramSurface = (surface) => {
-    if (!surface) {
-        return undefined;
-    }
-    return withDefinedEntries([
-        ["access", orderTelegramSurfaceAccess(surface.access)],
-        ["bot_token_secret", surface.bot_token_secret],
-        ["identity", surface.identity]
-    ]);
-};
-const orderTelegramSurfaceAccess = (access) => {
-    if (!access) {
-        return undefined;
-    }
-    return withDefinedEntries([
-        ["mode", access.mode],
-        ["users", access.users],
-        ["chats", access.chats]
-    ]);
-};
-const orderWebhookSurface = (surface) => {
-    if (!surface) {
-        return undefined;
-    }
-    return withDefinedEntries([
-        ["url", surface.url],
-        ["signing_secret", surface.signing_secret]
-    ]);
-};
-const orderMoltnetRoomBehavior = (behavior) => {
-    if (!behavior) {
-        return undefined;
-    }
-    return withDefinedEntries([
-        ["wake", behavior.wake]
-    ]);
-};
-const orderMoltnetDm = (dms) => {
-    if (!dms) {
-        return undefined;
-    }
-    return withDefinedEntries([
-        ["enabled", dms.enabled],
-        ["wake", dms.wake]
-    ]);
-};
-const orderMoltnetAttachment = (attachment) => withDefinedEntries([
-    ["network", attachment.network],
-    [
-        "rooms",
-        attachment.rooms
-            ? Object.fromEntries(Object.entries(attachment.rooms)
-                .sort(([left], [right]) => left.localeCompare(right))
-                .map(([roomId, behavior]) => [roomId, orderMoltnetRoomBehavior(behavior)]))
-            : undefined
-    ],
-    ["dms", orderMoltnetDm(attachment.dms)]
-]);
-const orderMoltnetSurface = (surface) => surface?.map(orderMoltnetAttachment);
-const orderWhatsAppSurface = (surface) => {
-    if (!surface) {
-        return undefined;
-    }
-    return withDefinedEntries([
-        ["access", orderWhatsAppSurfaceAccess(surface.access)],
-        ["identity", surface.identity]
-    ]);
-};
-const orderWhatsAppSurfaceAccess = (access) => {
-    if (!access) {
-        return undefined;
-    }
-    return withDefinedEntries([
-        ["mode", access.mode],
-        ["users", access.users],
-        ["groups", access.groups]
-    ]);
-};
-const orderSlackSurface = (surface) => {
-    if (!surface) {
-        return undefined;
-    }
-    return withDefinedEntries([
-        ["access", orderSlackSurfaceAccess(surface.access)],
-        ["bot_token_secret", surface.bot_token_secret],
-        ["app_token_secret", surface.app_token_secret],
-        ["identity", surface.identity]
-    ]);
-};
-const orderSlackSurfaceAccess = (access) => {
-    if (!access) {
-        return undefined;
-    }
-    return withDefinedEntries([
-        ["mode", access.mode],
-        ["users", access.users],
-        ["channels", access.channels]
-    ]);
-};
 const orderModelEntryAuth = (auth) => {
     if (!auth) {
         return undefined;
@@ -212,17 +94,25 @@ const orderSharedSurface = (shared) => {
         ["environment", orderEnvironment(shared.environment)]
     ]);
 };
-const orderSurfaces = (surfaces) => {
-    if (!surfaces) {
-        return undefined;
+const orderMember = (member) => {
+    if (isReferencedMember(member)) {
+        return withDefinedEntries([
+            ["id", member.id],
+            ["ref", member.ref]
+        ]);
     }
     return withDefinedEntries([
-        ["discord", orderDiscordSurface(surfaces.discord)],
-        ["telegram", orderTelegramSurface(surfaces.telegram)],
-        ["whatsapp", orderWhatsAppSurface(surfaces.whatsapp)],
-        ["slack", orderSlackSurface(surfaces.slack)],
-        ["webhook", orderWebhookSurface(surfaces.webhook)],
-        ["moltnet", orderMoltnetSurface(surfaces.moltnet)]
+        ["id", member.id],
+        ["description", member.description],
+        ["expose", member.expose],
+        ["runtime", orderRuntimeBinding(member.runtime)],
+        ["execution", orderExecution(member.execution)],
+        ["schedule", orderAgentSchedule(member.schedule)],
+        ["workspace", orderWorkspace(member.workspace)],
+        ["environment", orderEnvironment(member.environment)],
+        ["surfaces", orderSurfaces(member.surfaces)],
+        ["memory", member.memory],
+        ["policy", member.policy]
     ]);
 };
 const renderSections = (sections) => sections
@@ -256,11 +146,12 @@ const orderTeamManifestSections = (manifest) => [
     withDefinedEntries([["networks", orderTeamNetworks(manifest.networks)]]),
     withDefinedEntries([["policy", manifest.policy]]),
     withDefinedEntries([
-        ["members", manifest.members],
+        ["members", manifest.members.map(orderMember)],
         ["mode", manifest.mode],
         ["lead", manifest.lead],
         ["external", manifest.external]
-    ])
+    ]),
+    withDefinedEntries([["external_participants", manifest.external_participants]])
 ];
 export const renderSpawnfile = (manifest) => renderSections(manifest.kind === "agent"
     ? orderAgentManifestSections(manifest)

package/dist/manifest/renderSpawnfileNetworks.js

@@ -2,13 +2,15 @@ const withDefinedEntries = (entries) => Object.fromEntries(entries.filter((entry
 const orderTeamAuthToken = (token) => withDefinedEntries([
     ["id", token.id],
     ["agents", token.agents],
+    ["secret", token.secret],
     ["scopes", token.scopes]
 ]);
 const orderTeamAuthPairing = (pairing) => withDefinedEntries([
     ["id", pairing.id],
     ["remote_base_url", pairing.remote_base_url],
     ["remote_network_id", pairing.remote_network_id],
-    ["remote_network_name", pairing.remote_network_name]
+    ["remote_network_name", pairing.remote_network_name],
+    ["token_secret", pairing.token_secret]
 ]);
 const orderTeamStore = (server) => server.mode === "managed"
     ? withDefinedEntries([
@@ -72,7 +74,12 @@ export const orderTeamNetworks = (networks) => networks?.map((network) => withDe
     ["id", network.id],
     ["provider", network.provider],
     ["name", network.name],
-    ["server", orderTeamAuth(network.server)],
+    [
+        "server",
+        network.server
+            ? orderTeamAuth(network.server)
+            : undefined
+    ],
     [
         "rooms",
         network.rooms.map((room) => withDefinedEntries([

package/dist/manifest/renderSpawnfileSurfaces.d.ts

@@ -0,0 +1,2 @@
+import type { SurfacesBlock } from "./schemas.js";
+export declare const orderSurfaces: (surfaces: SurfacesBlock | undefined) => SurfacesBlock | undefined;