spawnfile 0.1.0

package/dist/manifest/schemas.js

@@ -0,0 +1,314 @@
+import { z } from "zod";
+import { surfacesSchema } from "./surfaceSchemas.js";
+const modelAuthMethodSchema = z.enum(["api_key", "claude-code", "codex", "none"]);
+const modelEndpointCompatibilitySchema = z.enum(["anthropic", "openai"]);
+const modelAuthSchema = z
+    .object({
+    method: modelAuthMethodSchema.optional(),
+    methods: z.record(z.string(), modelAuthMethodSchema).optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (!value.method && !value.methods) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "model auth must declare method or methods"
+        });
+    }
+    if (value.method && value.methods) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "model auth must not declare both method and methods"
+        });
+    }
+    if (value.methods && Object.keys(value.methods).length === 0) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "model auth methods must not be empty"
+        });
+    }
+});
+const modelEntryAuthMethodSchema = z.enum(["api_key", "claude-code", "codex", "none"]);
+const modelEntryAuthSchema = z
+    .object({
+    key: z.string().optional(),
+    method: modelEntryAuthMethodSchema.optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (!value.method) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "model auth must declare method"
+        });
+    }
+    if (value.key && value.method !== "api_key") {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "model auth key is only valid for api_key auth"
+        });
+    }
+});
+const modelEndpointSchema = z
+    .object({
+    base_url: z.string().min(1),
+    compatibility: modelEndpointCompatibilitySchema
+})
+    .strict();
+const modelTargetSchema = z
+    .object({
+    auth: modelEntryAuthSchema.optional(),
+    endpoint: modelEndpointSchema.optional(),
+    name: z.string(),
+    provider: z.string()
+})
+    .strict()
+    .superRefine((value, context) => {
+    const usesCustomEndpoint = value.provider === "custom" || value.provider === "local";
+    if (usesCustomEndpoint && !value.endpoint) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `${value.provider} models must declare endpoint`
+        });
+    }
+    if (!usesCustomEndpoint && value.endpoint) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "endpoint is only valid for custom or local models"
+        });
+    }
+});
+const docsSchema = z
+    .object({
+    extras: z.record(z.string(), z.string()).optional(),
+    heartbeat: z.string().optional(),
+    identity: z.string().optional(),
+    memory: z.string().optional(),
+    soul: z.string().optional(),
+    system: z.string().optional()
+})
+    .strict();
+const skillRequirementSchema = z
+    .object({
+    mcp: z.array(z.string()).optional()
+})
+    .strict();
+const skillReferenceSchema = z
+    .object({
+    ref: z.string(),
+    requires: skillRequirementSchema.optional()
+})
+    .strict();
+const mcpAuthSchema = z
+    .object({
+    secret: z.string()
+})
+    .strict();
+const mcpServerSchema = z
+    .object({
+    args: z.array(z.string()).optional(),
+    auth: mcpAuthSchema.optional(),
+    command: z.string().optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    name: z.string(),
+    transport: z.enum(["sse", "stdio", "streamable_http"]),
+    url: z.string().optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.transport === "stdio" && !value.command) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "stdio MCP servers must declare command"
+        });
+    }
+    if (value.transport !== "stdio" && !value.url) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `${value.transport} MCP servers must declare url`
+        });
+    }
+});
+const executionSchema = z
+    .object({
+    model: z
+        .object({
+        auth: modelAuthSchema.optional(),
+        fallback: z.array(modelTargetSchema).optional(),
+        primary: modelTargetSchema
+    })
+        .superRefine((value, context) => {
+        const declaredProviders = new Set([
+            value.primary.provider,
+            ...(value.fallback ?? []).map((model) => model.provider)
+        ]);
+        if (value.auth?.methods) {
+            for (const provider of declaredProviders) {
+                if (!(provider in value.auth.methods)) {
+                    context.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `model auth methods must declare provider ${provider}`
+                    });
+                }
+            }
+            for (const provider of Object.keys(value.auth.methods)) {
+                if (!declaredProviders.has(provider)) {
+                    context.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `model auth methods declared unknown provider ${provider}`
+                    });
+                }
+            }
+        }
+        for (const target of [value.primary, ...(value.fallback ?? [])]) {
+            const method = target.auth?.method ??
+                value.auth?.methods?.[target.provider] ??
+                value.auth?.method ??
+                (target.provider === "local" ? "none" : undefined);
+            if (target.provider === "custom" && !method) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: "custom models must declare auth.method or inherit legacy model auth"
+                });
+            }
+            if ((target.provider === "custom" || target.provider === "local") &&
+                method === "api_key" &&
+                !target.auth?.key) {
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `${target.provider} api_key auth must declare auth.key`
+                });
+            }
+        }
+    })
+        .strict()
+        .optional(),
+    sandbox: z
+        .object({
+        mode: z.enum(["sandboxed", "unrestricted", "workspace"])
+    })
+        .strict()
+        .optional(),
+    workspace: z
+        .object({
+        isolation: z.enum(["isolated", "shared"])
+    })
+        .strict()
+        .optional()
+})
+    .strict();
+const runtimeBindingSchema = z.union([
+    z.string().min(1),
+    z
+        .object({
+        name: z.string().min(1),
+        options: z.record(z.string(), z.unknown()).optional()
+    })
+        .strict()
+]);
+const secretSchema = z
+    .object({
+    name: z.string(),
+    required: z.boolean()
+})
+    .strict();
+const policySchema = z
+    .object({
+    mode: z.enum(["permissive", "strict", "warn"]),
+    on_degrade: z.enum(["allow", "error", "warn"])
+})
+    .strict();
+const commonManifestSchema = z
+    .object({
+    docs: docsSchema.optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    execution: executionSchema.optional(),
+    kind: z.enum(["agent", "team"]),
+    mcp_servers: z.array(mcpServerSchema).optional(),
+    name: z
+        .string()
+        .min(1)
+        .refine((value) => !/\s/.test(value), { message: "name must not contain whitespace" }),
+    policy: policySchema.optional(),
+    runtime: runtimeBindingSchema.optional(),
+    secrets: z.array(secretSchema).optional(),
+    skills: z.array(skillReferenceSchema).optional(),
+    surfaces: surfacesSchema.optional(),
+    spawnfile_version: z.literal("0.1")
+})
+    .strict();
+const subagentSchema = z
+    .object({
+    id: z.string().min(1),
+    ref: z.string()
+})
+    .strict();
+const sharedSurfaceSchema = z
+    .object({
+    env: z.record(z.string(), z.string()).optional(),
+    mcp_servers: z.array(mcpServerSchema).optional(),
+    secrets: z.array(secretSchema).optional(),
+    skills: z.array(skillReferenceSchema).optional()
+})
+    .strict();
+const structureSchema = z
+    .object({
+    external: z.array(z.string().min(1)).optional(),
+    leader: z.string().min(1).optional(),
+    mode: z.enum(["hierarchical", "swarm"])
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.mode === "hierarchical" && !value.leader) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "hierarchical teams must declare a leader"
+        });
+    }
+    if (value.mode === "swarm" && value.leader) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "swarm teams must not declare a leader"
+        });
+    }
+});
+const memberSchema = z
+    .object({
+    id: z.string().min(1),
+    ref: z.string()
+})
+    .strict();
+const agentManifestSchema = commonManifestSchema
+    .extend({
+    kind: z.literal("agent"),
+    subagents: z.array(subagentSchema).optional()
+})
+    .strict();
+const teamManifestSchema = commonManifestSchema
+    .extend({
+    kind: z.literal("team"),
+    members: z.array(memberSchema),
+    shared: sharedSurfaceSchema.optional(),
+    structure: structureSchema
+})
+    .superRefine((value, context) => {
+    if (value.execution !== undefined) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "team manifests must not declare execution"
+        });
+    }
+    if (value.surfaces !== undefined) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "team manifests must not declare surfaces"
+        });
+    }
+})
+    .strict();
+export const manifestSchema = z.discriminatedUnion("kind", [
+    agentManifestSchema,
+    teamManifestSchema
+]);
+export const isAgentManifest = (manifest) => manifest.kind === "agent";
+export const isTeamManifest = (manifest) => manifest.kind === "team";

package/dist/manifest/skillFrontmatter.d.ts

@@ -0,0 +1,5 @@
+export interface SkillFrontmatter {
+    description: string;
+    name: string;
+}
+export declare const parseSkillFrontmatter: (source: string) => SkillFrontmatter;

package/dist/manifest/skillFrontmatter.js

@@ -0,0 +1,32 @@
+import { parse as parseYaml } from "yaml";
+import { SpawnfileError } from "../shared/index.js";
+const readFrontmatterBlock = (source) => {
+    const lines = source.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---") {
+        throw new SpawnfileError("validation_error", "SKILL.md must begin with YAML frontmatter");
+    }
+    const closingIndex = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (closingIndex === -1) {
+        throw new SpawnfileError("validation_error", "SKILL.md must begin with YAML frontmatter");
+    }
+    return lines.slice(1, closingIndex).join("\n");
+};
+export const parseSkillFrontmatter = (source) => {
+    let parsed;
+    try {
+        parsed = parseYaml(readFrontmatterBlock(source));
+    }
+    catch {
+        throw new SpawnfileError("validation_error", "SKILL.md frontmatter must be valid YAML");
+    }
+    if (!parsed ||
+        typeof parsed !== "object" ||
+        typeof parsed.name !== "string" ||
+        typeof parsed.description !== "string") {
+        throw new SpawnfileError("validation_error", "Skill frontmatter must declare name and description");
+    }
+    return {
+        description: parsed.description,
+        name: parsed.name
+    };
+};

package/dist/manifest/surfaceSchemas.d.ts

@@ -0,0 +1,148 @@
+import { z } from "zod";
+declare const discordSurfaceAccessSchema: z.ZodObject<{
+    channels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    guilds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        allowlist: "allowlist";
+        open: "open";
+        pairing: "pairing";
+    }>>;
+    users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const telegramSurfaceAccessSchema: z.ZodObject<{
+    chats: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        allowlist: "allowlist";
+        open: "open";
+        pairing: "pairing";
+    }>>;
+    users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const whatsappSurfaceAccessSchema: z.ZodObject<{
+    groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        allowlist: "allowlist";
+        open: "open";
+        pairing: "pairing";
+    }>>;
+    users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const slackSurfaceAccessSchema: z.ZodObject<{
+    channels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        allowlist: "allowlist";
+        open: "open";
+        pairing: "pairing";
+    }>>;
+    users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const discordSurfaceSchema: z.ZodObject<{
+    access: z.ZodOptional<z.ZodObject<{
+        channels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        guilds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            allowlist: "allowlist";
+            open: "open";
+            pairing: "pairing";
+        }>>;
+        users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    bot_token_secret: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const telegramSurfaceSchema: z.ZodObject<{
+    access: z.ZodOptional<z.ZodObject<{
+        chats: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            allowlist: "allowlist";
+            open: "open";
+            pairing: "pairing";
+        }>>;
+        users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    bot_token_secret: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const whatsappSurfaceSchema: z.ZodObject<{
+    access: z.ZodOptional<z.ZodObject<{
+        groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            allowlist: "allowlist";
+            open: "open";
+            pairing: "pairing";
+        }>>;
+        users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const slackSurfaceSchema: z.ZodObject<{
+    access: z.ZodOptional<z.ZodObject<{
+        channels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            allowlist: "allowlist";
+            open: "open";
+            pairing: "pairing";
+        }>>;
+        users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    app_token_secret: z.ZodOptional<z.ZodString>;
+    bot_token_secret: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const surfacesSchema: z.ZodObject<{
+    discord: z.ZodOptional<z.ZodObject<{
+        access: z.ZodOptional<z.ZodObject<{
+            channels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            guilds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                allowlist: "allowlist";
+                open: "open";
+                pairing: "pairing";
+            }>>;
+            users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        bot_token_secret: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    slack: z.ZodOptional<z.ZodObject<{
+        access: z.ZodOptional<z.ZodObject<{
+            channels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                allowlist: "allowlist";
+                open: "open";
+                pairing: "pairing";
+            }>>;
+            users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        app_token_secret: z.ZodOptional<z.ZodString>;
+        bot_token_secret: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    telegram: z.ZodOptional<z.ZodObject<{
+        access: z.ZodOptional<z.ZodObject<{
+            chats: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                allowlist: "allowlist";
+                open: "open";
+                pairing: "pairing";
+            }>>;
+            users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        bot_token_secret: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    whatsapp: z.ZodOptional<z.ZodObject<{
+        access: z.ZodOptional<z.ZodObject<{
+            groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                allowlist: "allowlist";
+                open: "open";
+                pairing: "pairing";
+            }>>;
+            users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type DiscordSurfaceAccess = z.infer<typeof discordSurfaceAccessSchema>;
+export type DiscordSurface = z.infer<typeof discordSurfaceSchema>;
+export type SlackSurfaceAccess = z.infer<typeof slackSurfaceAccessSchema>;
+export type SlackSurface = z.infer<typeof slackSurfaceSchema>;
+export type TelegramSurfaceAccess = z.infer<typeof telegramSurfaceAccessSchema>;
+export type TelegramSurface = z.infer<typeof telegramSurfaceSchema>;
+export type WhatsAppSurfaceAccess = z.infer<typeof whatsappSurfaceAccessSchema>;
+export type WhatsAppSurface = z.infer<typeof whatsappSurfaceSchema>;
+export type SurfacesBlock = z.infer<typeof surfacesSchema>;
+export {};

package/dist/manifest/surfaceSchemas.js

@@ -0,0 +1,162 @@
+import { z } from "zod";
+const surfaceAccessModeSchema = z.enum(["allowlist", "open", "pairing"]);
+const discordSurfaceAccessSchema = z
+    .object({
+    channels: z.array(z.string().min(1)).optional(),
+    guilds: z.array(z.string().min(1)).optional(),
+    mode: surfaceAccessModeSchema.optional(),
+    users: z.array(z.string().min(1)).optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    const hasAllowlistEntries = (value.users?.length ?? 0) +
+        (value.guilds?.length ?? 0) +
+        (value.channels?.length ?? 0) >
+        0;
+    const mode = value.mode ?? (hasAllowlistEntries ? "allowlist" : undefined);
+    if (!mode) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "discord access must declare mode or allowlist entries"
+        });
+    }
+    if (mode !== "allowlist" && hasAllowlistEntries) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "discord access users, guilds, and channels are only valid for allowlist mode"
+        });
+    }
+    if (mode === "allowlist" && !hasAllowlistEntries) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "discord allowlist access must declare users, guilds, or channels"
+        });
+    }
+});
+const telegramSurfaceAccessSchema = z
+    .object({
+    chats: z.array(z.string().min(1)).optional(),
+    mode: surfaceAccessModeSchema.optional(),
+    users: z.array(z.string().min(1)).optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    const hasAllowlistEntries = (value.users?.length ?? 0) + (value.chats?.length ?? 0) > 0;
+    const mode = value.mode ?? (hasAllowlistEntries ? "allowlist" : undefined);
+    if (!mode) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "telegram access must declare mode or allowlist entries"
+        });
+    }
+    if (mode !== "allowlist" && hasAllowlistEntries) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "telegram access users and chats are only valid for allowlist mode"
+        });
+    }
+    if (mode === "allowlist" && !hasAllowlistEntries) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "telegram allowlist access must declare users or chats"
+        });
+    }
+});
+const whatsappSurfaceAccessSchema = z
+    .object({
+    groups: z.array(z.string().min(1)).optional(),
+    mode: surfaceAccessModeSchema.optional(),
+    users: z.array(z.string().min(1)).optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    const hasAllowlistEntries = (value.users?.length ?? 0) + (value.groups?.length ?? 0) > 0;
+    const mode = value.mode ?? (hasAllowlistEntries ? "allowlist" : undefined);
+    if (!mode) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "whatsapp access must declare mode or allowlist entries"
+        });
+    }
+    if (mode !== "allowlist" && hasAllowlistEntries) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "whatsapp access users and groups are only valid for allowlist mode"
+        });
+    }
+    if (mode === "allowlist" && !hasAllowlistEntries) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "whatsapp allowlist access must declare users or groups"
+        });
+    }
+});
+const slackSurfaceAccessSchema = z
+    .object({
+    channels: z.array(z.string().min(1)).optional(),
+    mode: surfaceAccessModeSchema.optional(),
+    users: z.array(z.string().min(1)).optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    const hasAllowlistEntries = (value.users?.length ?? 0) + (value.channels?.length ?? 0) > 0;
+    const mode = value.mode ?? (hasAllowlistEntries ? "allowlist" : undefined);
+    if (!mode) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "slack access must declare mode or allowlist entries"
+        });
+    }
+    if (mode !== "allowlist" && hasAllowlistEntries) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "slack access users and channels are only valid for allowlist mode"
+        });
+    }
+    if (mode === "allowlist" && !hasAllowlistEntries) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "slack allowlist access must declare users or channels"
+        });
+    }
+});
+const discordSurfaceSchema = z
+    .object({
+    access: discordSurfaceAccessSchema.optional(),
+    bot_token_secret: z.string().min(1).optional()
+})
+    .strict();
+const telegramSurfaceSchema = z
+    .object({
+    access: telegramSurfaceAccessSchema.optional(),
+    bot_token_secret: z.string().min(1).optional()
+})
+    .strict();
+const whatsappSurfaceSchema = z
+    .object({
+    access: whatsappSurfaceAccessSchema.optional()
+})
+    .strict();
+const slackSurfaceSchema = z
+    .object({
+    access: slackSurfaceAccessSchema.optional(),
+    app_token_secret: z.string().min(1).optional(),
+    bot_token_secret: z.string().min(1).optional()
+})
+    .strict();
+export const surfacesSchema = z
+    .object({
+    discord: discordSurfaceSchema.optional(),
+    slack: slackSurfaceSchema.optional(),
+    telegram: telegramSurfaceSchema.optional(),
+    whatsapp: whatsappSurfaceSchema.optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (!value.discord && !value.telegram && !value.whatsapp && !value.slack) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "surfaces must declare at least one surface"
+        });
+    }
+});

package/dist/report/createDiagnostic.d.ts

@@ -0,0 +1,2 @@
+import { DiagnosticReport } from "./types.js";
+export declare const createDiagnostic: (level: DiagnosticReport["level"], message: string) => DiagnosticReport;

package/dist/report/createDiagnostic.js

@@ -0,0 +1,4 @@
+export const createDiagnostic = (level, message) => ({
+    level,
+    message
+});

package/dist/report/createReport.d.ts

@@ -0,0 +1,2 @@
+import { CompileReport, ContainerReport, DiagnosticReport, NodeReport } from "./types.js";
+export declare const createCompileReport: (root: string, nodes: NodeReport[], diagnostics?: DiagnosticReport[], container?: ContainerReport) => CompileReport;

package/dist/report/createReport.js

@@ -0,0 +1,7 @@
+export const createCompileReport = (root, nodes, diagnostics = [], container) => ({
+    ...(container ? { container } : {}),
+    diagnostics,
+    nodes,
+    root,
+    spawnfile_version: "0.1"
+});

package/dist/report/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./createDiagnostic.js";
+export * from "./createReport.js";
+export * from "./types.js";
+export * from "./writeReport.js";