Function validateRenderAndSave

packages/hosts/mcp/src/tool-server.ts:1720–1801

(input: {
      readonly code: string;
      readonly title: string;
      readonly description?: string | undefined;
      readonly connections?: Readonly<Record<string, string>> | undefined;
      readonly existing: Artifact | null;
    })

     * would have refused.
     */
    const validateRenderAndSave = (input: {
      readonly code: string;
      readonly title: string;
      readonly description?: string | undefined;
      readonly connections?: Readonly<Record<string, string>> | undefined;
      readonly existing: Artifact | null;
    }): Effect.Effect<McpToolResult, unknown> =>
      Effect.gen(function* () {
        const rejection = validateArtifactCode(input.code);
        if (rejection) return renderRejectedResult(rejection);

        // Static checks first, then the real one: render it. See
        // `smokeRenderRejection` for what the model is told.
        //
        // FAIL OPEN. The renderer is injected, runs on three different hosts,
        // and is the newest thing in this path — if IT breaks (a missing
        // module, an environment gap on some host), the right outcome is a
        // saved artifact and a logged warning, never a refused create of code
        // that is perfectly good. Only a definite `failed` blocks a save.
        const smoke = config.smokeRenderArtifact;
        // The render that validates the artifact is also the render that
        // previews it: the same pass produces the loading-state markup the
        // gallery draws, so a preview costs nothing beyond sanitizing it.
        let preview: string | null = null;
        if (smoke) {
          const smokeResult: ArtifactSmokeRenderResult = yield* Effect.tryPromise(() =>
            smoke(input.code),
          ).pipe(
            Effect.catchCause((cause) =>
              Effect.as(Effect.logWarning("create-artifact smoke render was unavailable", cause), {
                status: "ok",
              } satisfies ArtifactSmokeRenderResult),
            ),
          );
          const renderRejection = smokeRenderRejection(smokeResult);
          if (renderRejection) {
            yield* Effect.annotateCurrentSpan({ "mcp.artifact.smoke_render": "failed" });
            return renderRejectedResult(renderRejection);
          }
          // Fail open, exactly as the verdict does: a preview that cannot be
          // produced or cannot be sanitized is a card that falls back to its
          // schematic, never a create that is refused.
          preview =
            smokeResult.status === "ok" && smokeResult.markup !== undefined
              ? sanitizeArtifactPreviewMarkup(smokeResult.markup)
              : null;
        }

        const saveInput = {
          code: input.code,
          title: input.title,
          preview,
          ...(input.description === undefined ? {} : { description: input.description }),
          ...(input.existing === null ? {} : { existingId: input.existing.id }),
        };

        const roles = extractArtifactRoles(input.code);
        if (roles.length === 0 && input.connections === undefined) {