spawnfile 0.1.11 → 0.1.13

package/dist/compiler/runProjectDocker.js

@@ -0,0 +1,202 @@
+import { execFile as execFileCallback, spawn } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+import { SpawnfileError } from "../shared/index.js";
+const execFile = promisify(execFileCallback);
+const parseDockerContextHost = (stdout) => {
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return typeof parsed === "string" ? parsed : null;
+    }
+    catch {
+        return trimmed;
+    }
+};
+const resolveSshDockerContext = async (invocation) => {
+    if (!invocation.dockerContext) {
+        return null;
+    }
+    const { stdout } = await execFile(invocation.command, [
+        "context",
+        "inspect",
+        invocation.dockerContext,
+        "--format",
+        "{{json .Endpoints.docker.Host}}"
+    ], { cwd: invocation.cwd, timeout: 10_000 });
+    const host = parseDockerContextHost(stdout);
+    if (!host?.startsWith("ssh://")) {
+        return null;
+    }
+    const url = new URL(host);
+    const user = decodeURIComponent(url.username);
+    const targetHost = url.hostname;
+    return {
+        host,
+        ...(url.port ? { port: url.port } : {}),
+        target: user ? `${user}@${targetHost}` : targetHost
+    };
+};
+const sshArgs = (context, command) => [
+    ...(context.port ? ["-p", context.port] : []),
+    context.target,
+    command
+];
+const scpArgs = (context, source, target) => [
+    ...(context.port ? ["-P", context.port] : []),
+    "-r",
+    source,
+    `${context.target}:${target}`
+];
+const shellQuote = (value) => `'${value.replace(/'/g, `'\"'\"'`)}'`;
+const createRemoteDirectory = async (context) => {
+    const { stdout } = await execFile("ssh", sshArgs(context, "mktemp -d /tmp/spawnfile-run-XXXXXX"), {
+        timeout: 10_000
+    });
+    return stdout.trim();
+};
+const copyPathToRemote = async (context, sourcePath, remotePath) => {
+    await execFile("scp", scpArgs(context, sourcePath, remotePath), { timeout: 120_000 });
+};
+const removeRemoteDirectory = async (context, remoteDirectory) => {
+    await execFile("ssh", sshArgs(context, `rm -rf ${shellQuote(remoteDirectory)}`), {
+        timeout: 10_000
+    });
+};
+const splitVolumeSpec = (spec) => {
+    const delimiter = spec.indexOf(":");
+    if (delimiter <= 0) {
+        return null;
+    }
+    return {
+        rest: spec.slice(delimiter),
+        source: spec.slice(0, delimiter)
+    };
+};
+const collectBindMountSources = (args) => {
+    const sources = new Set();
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] !== "-v" && args[index] !== "--volume") {
+            continue;
+        }
+        const volume = args[index + 1];
+        if (!volume) {
+            continue;
+        }
+        const parsed = splitVolumeSpec(volume);
+        if (parsed && path.isAbsolute(parsed.source)) {
+            sources.add(parsed.source);
+        }
+        index += 1;
+    }
+    return [...sources].sort();
+};
+const rewriteBindMountSources = (args, replacements) => args.map((arg, index) => {
+    const previous = args[index - 1];
+    if (previous !== "-v" && previous !== "--volume") {
+        return arg;
+    }
+    const parsed = splitVolumeSpec(arg);
+    if (!parsed) {
+        return arg;
+    }
+    const replacement = replacements.get(parsed.source);
+    return replacement ? `${replacement}${parsed.rest}` : arg;
+});
+const prepareRemoteBindMounts = async (invocation) => {
+    const context = await resolveSshDockerContext(invocation);
+    if (!context) {
+        return { cleanup: async () => undefined, invocation };
+    }
+    const sources = collectBindMountSources(invocation.args);
+    if (sources.length === 0) {
+        return { cleanup: async () => undefined, invocation };
+    }
+    const remoteDirectory = await createRemoteDirectory(context);
+    const replacements = new Map();
+    for (const [index, source] of sources.entries()) {
+        const remotePath = `${remoteDirectory}/${index}-${path.basename(source) || "mount"}`;
+        await copyPathToRemote(context, source, remotePath);
+        replacements.set(source, remotePath);
+    }
+    return {
+        cleanup: invocation.detach
+            ? async () => undefined
+            : async () => removeRemoteDirectory(context, remoteDirectory),
+        invocation: {
+            ...invocation,
+            args: rewriteBindMountSources(invocation.args, replacements)
+        }
+    };
+};
+const inspectImageArgs = (invocation, containerId) => {
+    const base = invocation.dockerContext
+        ? ["--context", invocation.dockerContext, "inspect"]
+        : invocation.dockerHost
+            ? ["--host", invocation.dockerHost, "inspect"]
+            : ["inspect"];
+    return [...base, "--format", "{{.Image}}", containerId];
+};
+const inspectDetachedImageId = async (invocation, containerId) => {
+    try {
+        const { stdout } = await execFile(invocation.command, inspectImageArgs(invocation, containerId), {
+            cwd: invocation.cwd,
+            timeout: 10_000
+        });
+        return stdout.trim() || undefined;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new SpawnfileError("runtime_error", `Unable to inspect detached container ${containerId} image id: ${message}`);
+    }
+};
+const runPreparedDockerContainer = (prepared) => new Promise((resolve, reject) => {
+    let stdout = "";
+    const child = spawn(prepared.invocation.command, prepared.invocation.args, {
+        cwd: prepared.invocation.cwd,
+        stdio: prepared.invocation.detach ? ["ignore", "pipe", "inherit"] : "inherit"
+    });
+    const settle = (finish) => {
+        prepared.cleanup().then(finish, reject);
+    };
+    const rejectAfterCleanup = (error) => {
+        prepared.cleanup().then(() => reject(error), reject);
+    };
+    if (prepared.invocation.detach && child.stdout) {
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+    }
+    child.once("error", (error) => {
+        rejectAfterCleanup(new SpawnfileError("runtime_error", `Unable to start docker run for ${prepared.invocation.imageTag}: ${error.message}`));
+    });
+    child.once("exit", (code, signal) => {
+        if (code === 0) {
+            const containerId = stdout.trim().split(/\s+/)[0];
+            if (!prepared.invocation.detach || !containerId) {
+                settle(() => resolve(undefined));
+                return;
+            }
+            inspectDetachedImageId(prepared.invocation, containerId)
+                .then((imageId) => resolve({ containerId, ...(imageId ? { imageId } : {}) }))
+                .catch(reject);
+            return;
+        }
+        rejectAfterCleanup(new SpawnfileError("runtime_error", signal
+            ? `Docker run for ${prepared.invocation.imageTag} exited from signal ${signal}`
+            : `Docker run for ${prepared.invocation.imageTag} failed with exit code ${code ?? "unknown"}`));
+    });
+});
+export const runDockerContainer = (invocation) => {
+    if (!invocation.dockerContext || collectBindMountSources(invocation.args).length === 0) {
+        return runPreparedDockerContainer({
+            cleanup: async () => undefined,
+            invocation
+        });
+    }
+    return prepareRemoteBindMounts(invocation).then(runPreparedDockerContainer);
+};

package/dist/compiler/types.d.ts

@@ -82,8 +82,7 @@ export interface ResolvedHttpSurface {
     port?: number;
 }
 export interface ResolvedMoltnetRoomPolicy {
-    read?: "all" | "mentions" | "thread_only";
-    reply?: "auto" | "never";
+    wake?: "all" | "mentions" | "thread_only" | "never";
 }
 export interface ResolvedMoltnetDMConfig extends ResolvedMoltnetRoomPolicy {
     enabled: boolean;

package/dist/compiler/upProject.d.ts

@@ -1,3 +1,4 @@
+import { type DockerTargetExecFile } from "../deployment/index.js";
 import { type BuildProjectResult, type DockerBuildRunner } from "./buildProject.js";
 import { type DockerRunRunner } from "./runProject.js";
 import { CompileProjectOptions } from "./compileProject.js";
@@ -6,14 +7,19 @@ export interface UpProjectOptions extends CompileProjectOptions {
     buildRunner?: DockerBuildRunner;
     containerName?: string;
     detach?: boolean;
+    deploymentName?: string;
     dockerCommand?: string;
+    dockerContext?: string;
+    dockerHost?: string;
     envFilePath?: string;
     imageTag?: string;
     runRunner?: DockerRunRunner;
+    targetExecFile?: DockerTargetExecFile;
 }
 export interface UpProjectResult extends BuildProjectResult {
     authProfileName: string | null;
     containerName: string | null;
+    deploymentRecordPath?: string | null;
     supportDirectory: string | null;
 }
 export declare const upProject: (inputPath: string, options?: UpProjectOptions) => Promise<UpProjectResult>;

package/dist/compiler/upProject.js

@@ -1,37 +1,72 @@
+import path from "node:path";
 import { removeDirectory } from "../filesystem/index.js";
+import { writeDockerDeploymentRecordForRun } from "../deployment/index.js";
 import { buildProject } from "./buildProject.js";
-import { createDockerRunInvocation, runDockerContainer } from "./runProject.js";
+import { createDockerRunInvocation, resolveDetachedDeploymentOptions, runDockerContainer } from "./runProject.js";
 import { requireAuthProfile } from "../auth/index.js";
+import { DEFAULT_OUTPUT_DIRECTORY } from "../shared/index.js";
 export const upProject = async (inputPath, options = {}) => {
+    const resolvedOptions = await resolveDetachedDeploymentOptions(path.resolve(options.outputDirectory ?? DEFAULT_OUTPUT_DIRECTORY), {
+        authProfile: options.authProfile,
+        containerName: options.containerName,
+        deploymentName: options.deploymentName,
+        detach: options.detach,
+        dockerCommand: options.dockerCommand,
+        dockerContext: options.dockerContext,
+        dockerHost: options.dockerHost,
+        envFilePath: options.envFilePath,
+        imageTag: options.imageTag,
+        targetExecFile: options.targetExecFile
+    });
     const buildResult = await buildProject(inputPath, {
         buildRunner: options.buildRunner,
         clean: options.clean,
+        dockerContext: resolvedOptions.dockerContext,
         dockerCommand: options.dockerCommand,
-        imageTag: options.imageTag,
+        imageTag: resolvedOptions.imageTag,
         outputDirectory: options.outputDirectory
     });
-    const authProfile = options.authProfile
-        ? await requireAuthProfile(options.authProfile)
+    const authProfile = resolvedOptions.authProfile
+        ? await requireAuthProfile(resolvedOptions.authProfile)
         : null;
-    const invocation = await createDockerRunInvocation(buildResult, buildResult.imageTag, {
+    const imageTag = resolvedOptions.imageTag ?? buildResult.imageTag;
+    const invocation = await createDockerRunInvocation(buildResult, imageTag, {
         authProfile,
-        containerName: options.containerName,
+        containerName: resolvedOptions.containerName,
         detach: options.detach,
+        deploymentName: resolvedOptions.deploymentName,
         dockerCommand: options.dockerCommand,
-        envFilePath: options.envFilePath
+        dockerContext: resolvedOptions.dockerContext,
+        dockerHost: resolvedOptions.dockerHost,
+        envFilePath: resolvedOptions.envFilePath
     });
+    let runMetadata;
     try {
-        await (options.runRunner ?? runDockerContainer)(invocation);
+        runMetadata = await (options.runRunner ?? runDockerContainer)(invocation);
     }
     finally {
         if (!invocation.detach) {
             await removeDirectory(invocation.supportDirectory);
         }
     }
+    const deploymentRecordPath = invocation.detach && invocation.deploymentName
+        ? await writeDockerDeploymentRecordForRun({
+            authProfileName: authProfile?.name ?? null,
+            envFilePath: resolvedOptions.envFilePath,
+            imageTag,
+            invocation,
+            outputDirectory: buildResult.outputDirectory,
+            report: buildResult.report,
+            runMetadata: runMetadata ?? undefined,
+            targetExecFile: options.targetExecFile
+        })
+        : null;
     return {
         ...buildResult,
         authProfileName: authProfile?.name ?? null,
         containerName: invocation.containerName,
+        deploymentRecordPath,
+        imageTag,
         supportDirectory: invocation.supportDirectory
     };
 };

package/dist/compiler/view/buildOrganizationView.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { SpawnfileError } from "../../shared/index.js";
 import { buildCompilePlan } from "../buildCompilePlan.js";
 import { resolveMoltnetRoomMemberships } from "../moltnetRoomMemberships.js";
+import { buildDeclaredNodeView, buildRuntimeViews } from "./declarations.js";
 const createNameCounts = (plan) => {
     const counts = new Map();
     for (const node of plan.nodes) {
@@ -82,7 +83,9 @@ const buildTreeNode = (node, nodeById, edgesBySource, nameCounts, ancestors = []
         kind: node.kind,
         name: node.value.name,
         networks: buildTreeNetworkSummaries(node),
+        declared: buildDeclaredNodeView(node),
         runtimeName: node.runtimeName,
+        slug: node.slug,
         source: node.value.source
     };
 };
@@ -219,6 +222,6 @@ export const buildOrganizationView = async (inputPath) => {
         networks: buildNetworks(plan),
         projectRoot: path.dirname(plan.root),
         root,
-        runtimes: []
+        runtimes: buildRuntimeViews(plan)
     };
 };

package/dist/compiler/view/declarations.d.ts

@@ -0,0 +1,4 @@
+import type { CompilePlan, CompilePlanNode } from "../types.js";
+import type { OrganizationRuntimeView, OrganizationViewDeclaredSummary } from "./types.js";
+export declare const buildDeclaredNodeView: (node: CompilePlanNode) => OrganizationViewDeclaredSummary;
+export declare const buildRuntimeViews: (plan: CompilePlan) => OrganizationRuntimeView[];

package/dist/compiler/view/declarations.js

@@ -0,0 +1,104 @@
+import { resolveEffectiveModelTarget } from "../modelEnv.js";
+import { listInteractiveSurfaceScopes } from "../interactiveSurfaceScopes.js";
+const summarizeModel = (node) => {
+    if (node.value.kind !== "agent" || !node.value.execution?.model?.primary) {
+        return null;
+    }
+    const target = resolveEffectiveModelTarget(node.value.execution.model.primary, node.value.execution);
+    return {
+        authMethod: target.auth.method,
+        name: target.name,
+        provider: target.provider
+    };
+};
+const summarizeSchedule = (node) => {
+    if (node.value.kind !== "agent" || !node.value.schedule) {
+        return null;
+    }
+    const schedule = node.value.schedule;
+    if (schedule.kind === "cron") {
+        return {
+            expression: schedule.cron,
+            kind: schedule.kind,
+            ...(schedule.timezone ? { timezone: schedule.timezone } : {})
+        };
+    }
+    if (schedule.kind === "every") {
+        return {
+            expression: schedule.every,
+            kind: schedule.kind,
+            ...(schedule.timezone ? { timezone: schedule.timezone } : {})
+        };
+    }
+    return { kind: schedule.kind };
+};
+const surfaceSummaryFor = (name, surfaces) => {
+    if (!surfaces[name]) {
+        return null;
+    }
+    const scopes = name === "moltnet"
+        ? listInteractiveSurfaceScopes(surfaces).filter((scope) => scope.startsWith("moltnet:"))
+        : listInteractiveSurfaceScopes(surfaces).filter((scope) => scope === name);
+    return {
+        name,
+        scopes: scopes.length > 0 ? scopes : [name]
+    };
+};
+const summarizeSurfaces = (node) => {
+    const surfaces = node.value.kind === "agent" ? node.value.surfaces : undefined;
+    if (!surfaces) {
+        return [];
+    }
+    return ["discord", "http", "moltnet", "slack", "telegram", "webhook", "whatsapp"]
+        .map((name) => surfaceSummaryFor(name, surfaces))
+        .filter((surface) => surface !== null);
+};
+const summarizePackages = (node) => {
+    const packages = node.value.kind === "agent"
+        ? node.value.packages ?? []
+        : node.value.shared.packages ?? [];
+    return packages.map((pkg) => ({
+        id: pkg.id,
+        manager: pkg.manager,
+        name: pkg.name,
+        ...(pkg.scope ? { scope: pkg.scope } : {}),
+        ...(pkg.version ? { version: pkg.version } : {})
+    }));
+};
+const summarizeResources = (node) => (node.value.workspaceResources ?? []).map((resource) => ({
+    id: resource.id,
+    kind: resource.kind,
+    mode: resource.mode,
+    mount: resource.mount,
+    sharing: resource.sharing
+}));
+export const buildDeclaredNodeView = (node) => {
+    const skills = node.value.kind === "agent" ? node.value.skills : node.value.shared.skills;
+    const mcpServers = node.value.kind === "agent"
+        ? node.value.mcpServers
+        : node.value.shared.mcpServers;
+    return {
+        docs: node.value.docs.map((doc) => ({ role: doc.role, source: doc.sourcePath })),
+        mcpServers: mcpServers.map((server) => ({
+            name: server.name,
+            transport: server.transport
+        })),
+        model: summarizeModel(node),
+        packages: summarizePackages(node),
+        policy: {
+            mode: node.value.policyMode,
+            onDegrade: node.value.policyOnDegrade
+        },
+        resources: summarizeResources(node),
+        schedule: summarizeSchedule(node),
+        skills: skills.map((skill) => ({
+            name: skill.name,
+            ref: skill.ref,
+            requiresMcp: [...skill.requiresMcp]
+        })),
+        surfaces: summarizeSurfaces(node)
+    };
+};
+export const buildRuntimeViews = (plan) => Object.entries(plan.runtimes)
+    .map(([name, runtime]) => ({ name, nodeIds: [...runtime.nodeIds].sort() }))
+    .sort((left, right) => left.name.localeCompare(right.name));

package/dist/compiler/view/renderNetworks.js

@@ -8,8 +8,7 @@ const formatPolicy = (member) => {
         return [];
     }
     return [
-        member.policy.read ? `read=${member.policy.read}` : undefined,
-        member.policy.reply ? `reply=${member.policy.reply}` : undefined
+        member.policy.wake ? `wake=${member.policy.wake}` : undefined
     ].filter((entry) => entry !== undefined);
 };
 const formatMember = (member, options, projectRoot) => {

package/dist/compiler/view/renderTree.js

@@ -1,5 +1,9 @@
 import { formatSourceMeta } from "./sourcePaths.js";
 const color = (value, code, options) => options.color ? `\u001b[${code}m${value}\u001b[0m` : value;
+const formatAnnotations = (subjectKey, options) => {
+    const annotations = options.annotationFor?.(subjectKey) ?? [];
+    return annotations.length > 0 ? `  ${annotations.join(" ")}` : "";
+};
 const formatNode = (node, options, projectRoot) => {
     const kind = color(node.kind, node.kind === "team" ? "36" : "32", options);
     const metadata = node.kind === "team"
@@ -17,7 +21,7 @@ const formatNode = (node, options, projectRoot) => {
     const details = metadata.filter((entry) => entry !== undefined);
     const source = options.paths ? formatSourceMeta("source", node.source, projectRoot) : "";
     const separator = details[0]?.startsWith("[") ? " " : "  ";
-    return `${kind} ${node.displayName}${details.length > 0 ? `${separator}${details.join(" ")}` : ""}${source}`;
+    return `${kind} ${node.displayName}${details.length > 0 ? `${separator}${details.join(" ")}` : ""}${source}${formatAnnotations(node.id, options)}`;
 };
 const formatEdgeLabel = (edge) => edge.relation === "subagent"
     ? `subagent ${edge.label}`
@@ -44,7 +48,7 @@ const formatNetworkSummary = (network, options) => {
         return `${room.id}${roomMetadata.length > 0 ? ` ${roomMetadata.join(" ")}` : ""} [${room.declaredMembers.join(", ")}]`;
     })
         .join("; ");
-    return `network ${id} "${network.name}"${metadata.length > 0 ? ` ${metadata.join(" ")}` : ""}: ${rooms}`;
+    return `network ${id} "${network.name}"${metadata.length > 0 ? ` ${metadata.join(" ")}` : ""}: ${rooms}${formatAnnotations(`network:${network.id}`, options)}`;
 };
 const renderChildren = (node, options, projectRoot, prefix = "") => {
     const glyphs = options.ascii

package/dist/compiler/view/types.d.ts

@@ -1,6 +1,63 @@
 import type { ResolvedMoltnetRoomPolicy } from "../types.js";
+export interface OrganizationViewDocSummary {
+    role: string;
+    source: string;
+}
+export interface OrganizationViewSkillSummary {
+    name: string;
+    ref: string;
+    requiresMcp: string[];
+}
+export interface OrganizationViewResourceSummary {
+    id: string;
+    kind: "git" | "volume";
+    mode: "mutable" | "readonly";
+    mount: string;
+    sharing: "per_agent" | "team";
+}
+export interface OrganizationViewPackageSummary {
+    id: string;
+    manager: string;
+    name: string;
+    scope?: string;
+    version?: string;
+}
+export interface OrganizationViewMcpSummary {
+    name: string;
+    transport: "sse" | "stdio" | "streamable_http";
+}
+export interface OrganizationViewModelSummary {
+    authMethod: string;
+    name: string;
+    provider: string;
+}
+export interface OrganizationViewScheduleSummary {
+    expression?: string;
+    kind: "cron" | "disabled" | "every";
+    timezone?: string;
+}
+export interface OrganizationViewSurfaceSummary {
+    name: string;
+    scopes: string[];
+}
+export interface OrganizationViewPolicySummary {
+    mode: string | null;
+    onDegrade: string | null;
+}
+export interface OrganizationViewDeclaredSummary {
+    docs: OrganizationViewDocSummary[];
+    mcpServers: OrganizationViewMcpSummary[];
+    model: OrganizationViewModelSummary | null;
+    packages: OrganizationViewPackageSummary[];
+    policy: OrganizationViewPolicySummary;
+    resources: OrganizationViewResourceSummary[];
+    schedule: OrganizationViewScheduleSummary | null;
+    skills: OrganizationViewSkillSummary[];
+    surfaces: OrganizationViewSurfaceSummary[];
+}
 export interface OrganizationViewTreeNode {
     children: OrganizationViewTreeEdge[];
+    declared?: OrganizationViewDeclaredSummary;
     displayName: string;
     external?: string[];
     id: string;
@@ -10,6 +67,7 @@ export interface OrganizationViewTreeNode {
     name: string;
     networks?: OrganizationTreeNetworkSummary[];
     runtimeName: string | null;
+    slug?: string;
     source: string;
 }
 export interface OrganizationTreeNetworkRoomSummary {
@@ -94,6 +152,10 @@ export interface OrganizationNetworkView {
     url?: string;
     declarations?: OrganizationNetworkDeclarationView[];
 }
+export interface OrganizationRuntimeView {
+    name: string;
+    nodeIds: string[];
+}
 export interface OrganizationView {
     contexts: [];
     diagnostics: [];
@@ -101,9 +163,10 @@ export interface OrganizationView {
     networks: OrganizationNetworkView[];
     projectRoot?: string;
     root: OrganizationViewTreeNode;
-    runtimes: [];
+    runtimes: OrganizationRuntimeView[];
 }
 export interface RenderOrganizationViewOptions {
+    annotationFor?: (subjectKey: string) => string[];
     ascii?: boolean;
     color?: boolean;
     declared?: boolean;

package/dist/deployment/dockerInspect.d.ts

@@ -0,0 +1,29 @@
+import type { DeploymentRecord } from "./record.js";
+export type DockerInspectExecFile = (file: string, args: string[], options: {
+    timeout: number;
+}) => Promise<{
+    stderr: string;
+    stdout: string;
+}>;
+export interface DockerUnitInspection {
+    containerId: string | null;
+    drift: string[];
+    exists: boolean | null;
+    exitCode: number | null;
+    finishedAt: string | null;
+    imageId: string | null;
+    message: string;
+    restartCount: number | null;
+    running: boolean | null;
+    severity: "error" | "ok" | "unknown" | "warn";
+    startedAt: string | null;
+    status: string | null;
+    unitId: string;
+}
+export type DockerInspectionResult = Map<string, DockerUnitInspection>;
+export interface DockerInspectOptions {
+    dockerCommand?: string;
+    execFile?: DockerInspectExecFile;
+    timeoutMs?: number;
+}
+export declare const inspectDockerDeployment: (record: DeploymentRecord, options?: DockerInspectOptions) => Promise<DockerInspectionResult>;