@distilled.cloud/core 1.0.0-rc.12 → 1.0.0-rc.13

package/src/codegen/graphql-client.ts

@@ -206,114 +206,236 @@ export interface GenerateGraphQLClientOptions {
   readonly requirementsImport: string;
   /** Optional legacy-name aliases, e.g. createProject -> projectCreate. */
   readonly operationAliases?: Readonly<Record<string, string>>;
+  /** Export name for the root object (`Railway`, `Eas`, …). Default `"Sdk"`. */
+  readonly sdkName?: string;
 }
 
-/** Emit schema-indexed types and the matching runtime graph from one patched model. */
+const peelRef = (
+  ref: string,
+): { name: string; list: boolean; nonNull: boolean } => {
+  let text = ref;
+  let nonNull = false;
+  let list = false;
+  if (text.endsWith("!")) {
+    nonNull = true;
+    text = text.slice(0, -1);
+  }
+  if (text.startsWith("[") && text.endsWith("]")) {
+    list = true;
+    text = text.slice(1, -1);
+    if (text.endsWith("!")) text = text.slice(0, -1);
+  }
+  return { name: text, list, nonNull };
+};
+
+/**
+ * Emit a Query-algebra SDK: TypeMeta + TS types + named roots
+ * (`me`, `project`, …). Combinators stay in `@distilled.cloud/core/query`;
+ * this file only describes the schema as lazy lenses.
+ */
 export const generateGraphQLClient = (
   model: GraphQLModel,
   options: GenerateGraphQLClientOptions,
 ): string => {
   validateGraphQLModel(model);
-  const inputType = (ref: string): string => {
-    if (ref.endsWith("!")) return requiredInput(ref.slice(0, -1));
-    return `${requiredInput(ref)} | null`;
+  const sdkName = options.sdkName ?? "Sdk";
+  const skipRoots = new Set(
+    [model.queryType, model.mutationType, model.subscriptionType].filter(
+      (name): name is string => typeof name === "string",
+    ),
+  );
+  const tsNamed = (name: string): string => {
+    const type = model.types[name];
+    if (!type) return "unknown";
+    if (type.kind === "SCALAR") return type.scalar ?? "unknown";
+    if (type.kind === "ENUM")
+      return (
+        (type.enumValues ?? [])
+          .map((value) => JSON.stringify(value))
+          .join(" | ") || "string"
+      );
+    if (type.kind === "UNION")
+      return (
+        (type.possibleTypes ?? []).filter(Boolean).join(" | ") || "unknown"
+      );
+    return name;
   };
-  const requiredInput = (ref: string): string => {
-    if (ref.startsWith("["))
-      return `ReadonlyArray<${inputType(ref.slice(1, -1))}>`;
-    const type = model.types[ref]!;
-    return type.kind === "INPUT_OBJECT"
-      ? `Inputs[${literal(ref)}]`
-      : `Scalars[${literal(ref)}]`;
+  /** Relay `edges { node }` → node type name, else undefined. */
+  const connectionNode = (typeName: string): string | undefined => {
+    const type = model.types[typeName];
+    const edges = type?.fields?.edges;
+    if (!edges) return undefined;
+    const edgeRef = peelRef(edges.type);
+    if (!edgeRef.list) return undefined;
+    const node = model.types[edgeRef.name]?.fields?.node;
+    if (!node) return undefined;
+    const nodeName = peelRef(node.type).name;
+    const kind = model.types[nodeName]?.kind;
+    if (kind !== "OBJECT" && kind !== "INTERFACE" && kind !== "UNION") {
+      return undefined;
+    }
+    return nodeName;
   };
-  const argsType = (args: Record<string, GraphQLArgument>): string =>
-    `{ ${Object.entries(args)
-      .map(
-        ([name, arg]) =>
-          `${literal(name)}${arg.type.endsWith("!") && arg.defaultValue === undefined ? "" : "?"}: ${inputType(arg.type)}`,
-      )
-      .join("; ")} }`;
-  // GraphQL names are not necessarily valid or unoccupied TypeScript symbols.
-  // Schema names remain quoted map keys; exported values get stable safe names.
-  const occupied = new Set([
-    ..."await break case catch class const continue debugger default delete do else enum export extends false finally for function if import in instanceof new null return super switch this throw true try typeof var void while with yield implements interface let package private protected public static arguments eval abstract any as asserts async bigint boolean constructor declare from get global infer intrinsic is keyof module namespace never number object of override readonly require satisfies set string symbol type undefined unique unknown using".split(
-      " ",
-    ),
-    "G",
-    "S",
-    "Category",
-    "Scalars",
-    "Inputs",
-    "Errors",
-    "Types",
-    "PossibleTypes",
-    "Schema",
-    "Selection",
-    "Result",
-    "SelectedErrors",
-    "GraphQLIssue",
-    "Report",
-    "catchTags",
-    "isErrorTag",
-    "GraphQLFailure",
-    "GraphQLTransportError",
-    "GraphQLDecodeError",
-    "GraphQLRequestError",
-    "UnknownGraphQLError",
-    "query",
-    "mutation",
-    "report",
-    "client",
-    "schema",
-    "errorClasses",
-    options.transportName ?? "transport",
-    options.requirementsType,
+  /** Input type: nullable GraphQL inputs (no `!`) accept `null`. */
+  const tsArg = (ref: string): string => {
+    const nonNull = ref.endsWith("!");
+    const inner = nonNull ? ref.slice(0, -1) : ref;
+    const ts =
+      inner.startsWith("[") && inner.endsWith("]")
+        ? `ReadonlyArray<${tsArg(inner.slice(1, -1))}>`
+        : tsNamed(inner);
+    return nonNull ? ts : `${ts} | null`;
+  };
+  /** Response type: nullable GraphQL types (no `!`) include `null`. */
+  const tsOutput = (ref: string): string => {
+    const nonNull = ref.endsWith("!");
+    const inner = nonNull ? ref.slice(0, -1) : ref;
+    let ts: string;
+    if (inner.startsWith("[") && inner.endsWith("]")) {
+      ts = `ReadonlyArray<${tsOutput(inner.slice(1, -1))}>`;
+    } else {
+      const node = connectionNode(inner);
+      ts = node ? `ReadonlyArray<${tsNamed(node)}>` : tsNamed(inner);
+    }
+    return nonNull ? ts : `${ts} | null`;
+  };
+  const isObjectLike = (name: string): boolean => {
+    const kind = model.types[name]?.kind;
+    return kind === "OBJECT" || kind === "INTERFACE";
+  };
+  const fieldMeta = (fieldName: string, field: GraphQLField): string => {
+    const { name, list } = peelRef(field.type);
+    const argTypes = Object.keys(field.args).length
+      ? `{ ${Object.entries(field.args)
+          .map(([argName, arg]) => `${argName}: ${JSON.stringify(arg.type)}`)
+          .join(", ")} }`
+      : undefined;
+    const node = !list ? connectionNode(name) : undefined;
+    if (node) {
+      return argTypes
+        ? `connectionField(${JSON.stringify(fieldName)}, ${node}, ${argTypes})`
+        : `connectionField(${JSON.stringify(fieldName)}, ${node})`;
+    }
+    if (list && isObjectLike(name)) {
+      return argTypes
+        ? `listField(${JSON.stringify(fieldName)}, ${name}, ${argTypes})`
+        : `listField(${JSON.stringify(fieldName)}, ${name})`;
+    }
+    if (isObjectLike(name) || model.types[name]?.kind === "UNION") {
+      return `objectField(${JSON.stringify(fieldName)}, ${name})`;
+    }
+    return `scalarField(${JSON.stringify(fieldName)})`;
+  };
+  // Errors: one tagged class per declared error, a runtime spec per class,
+  // and per-root error unions (field errors ∪ global errors).
+  const errorTags = Object.keys(model.errors).sort();
+  const globalErrorType = `${sdkName}GlobalError`;
+  const reserved = new Set([
+    ...Object.keys(model.types),
+    sdkName,
+    `${sdkName}Error`,
+    globalErrorType,
   ]);
-  const identifier = (name: string) =>
-    name.replace(/[^A-Za-z0-9_$]/g, "_").replace(/^(?=[0-9])/, "_") ||
-    "generated";
-  const allocate = (preferred: string, fallback: string): string => {
-    let name = identifier(preferred);
-    if (occupied.has(name)) name = identifier(fallback);
-    const base = name;
-    for (let suffix = 2; occupied.has(name); suffix++)
-      name = `${base}${suffix}`;
-    occupied.add(name);
-    return name;
+  for (const tag of errorTags) {
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(tag))
+      throw new Error(`GraphQL error tag ${tag} is not a valid identifier`);
+    for (const name of [tag, `${tag}Spec`])
+      if (reserved.has(name))
+        throw new Error(`GraphQL error ${tag} collides with ${name}`);
+  }
+  const globalErrors = [...model.globalErrors].sort();
+  const rootErrors = (field: GraphQLField) => {
+    const fieldOnly = [...new Set(field.errors)]
+      .filter((tag) => !globalErrors.includes(tag))
+      .sort();
+    const type = union([...fieldOnly, globalErrorType]);
+    const specs = fieldOnly.length
+      ? `[${fieldOnly.map((tag) => `${tag}Spec`).join(", ")}, ...globalErrors]`
+      : "globalErrors";
+    return { type, specs };
   };
-  const errorNames = new Map(
-    Object.keys(model.errors).map((tag) => [
-      tag,
-      allocate(tag, `${identifier(tag)}Error`),
-    ]),
-  );
+  const rootFn = (
+    kind: "query" | "mutation",
+    fieldName: string,
+    field: GraphQLField,
+  ): string => {
+    const errors = rootErrors(field);
+    const { name, list } = peelRef(field.type);
+    const node = !list ? connectionNode(name) : undefined;
+    const resultTs = tsOutput(field.type);
+    const argEntries = Object.entries(field.args);
+    const argTypes =
+      argEntries.length > 0
+        ? `{ ${argEntries.map(([argName, arg]) => `${argName}: ${JSON.stringify(arg.type)}`).join(", ")} }`
+        : undefined;
+    const required = argEntries.filter(([, arg]) => arg.type.endsWith("!"));
+    const optional = argEntries.filter(([, arg]) => !arg.type.endsWith("!"));
+    const argFields = [
+      ...required.map(
+        ([argName, arg]) => `readonly ${argName}: ${tsArg(arg.type)}`,
+      ),
+      ...optional.map(
+        ([argName, arg]) => `readonly ${argName}?: ${tsArg(arg.type)}`,
+      ),
+    ].join("; ");
+    const sig =
+      argEntries.length === 0
+        ? ""
+        : required.length === 0
+          ? `args?: { ${argFields} }`
+          : `args: { ${argFields} }`;
+    const argsExpr = argEntries.length === 0 ? ", undefined" : ", args";
+    const argTypesExpr = argTypes ? `, ${argTypes}` : ", undefined";
+    const rest = `${argsExpr}${argTypesExpr}, ${errors.specs}`;
+    const result = `Query<${resultTs}, ${errors.type}>`;
+    const call = (helper: string, target: string) =>
+      `${helper}(${JSON.stringify(kind)}, ${JSON.stringify(fieldName)}, ${target}${rest})`;
+    const body = node
+      ? call("rootConnection", node)
+      : isObjectLike(name)
+        ? call(list ? "rootList" : "root", name)
+        : call("rootLeaf", String(list));
+    return `  ${fieldName}: (${sig}): ${result} =>\n    ${body},`;
+  };
+
+  const objects: string[] = [];
+  const enums: string[] = [];
+  const inputs: string[] = [];
+  const unions: string[] = [];
+  for (const [name, type] of Object.entries(model.types)) {
+    if (name.startsWith("__") || skipRoots.has(name)) continue;
+    if (type.kind === "OBJECT" || type.kind === "INTERFACE") objects.push(name);
+    else if (type.kind === "ENUM") enums.push(name);
+    else if (type.kind === "INPUT_OBJECT") inputs.push(name);
+    else if (type.kind === "UNION") unions.push(name);
+  }
+  objects.sort();
+  enums.sort();
+  inputs.sort();
+  unions.sort();
+
   const lines: string[] = [
     "// Generated by @distilled.cloud/core/codegen/graphql-client. DO NOT EDIT.",
-    'import * as G from "@distilled.cloud/core/graphql";',
-    'import * as S from "effect/Schema";',
-    'import * as Category from "@distilled.cloud/core/category";',
-    `import { ${options.transportName ?? "transport"} } from ${literal(options.transportImport)};`,
-    `import type { ${options.requirementsType} } from ${literal(options.requirementsImport)};`,
-    `export type { ${options.requirementsType} } from ${literal(options.requirementsImport)};`,
-    'export { catchTags, isErrorTag, GraphQLFailure, GraphQLTransportError, GraphQLDecodeError, GraphQLRequestError, UnknownGraphQLError, type GraphQLIssue, type Report } from "@distilled.cloud/core/graphql";',
+    `import * as S from "effect/Schema";`,
+    `import * as Category from "@distilled.cloud/core/category";`,
+    `import {`,
+    `  connectionField,`,
+    `  errorFields,`,
+    `  errorSpec,`,
+    `  listField,`,
+    `  objectField,`,
+    `  root,`,
+    `  rootConnection,`,
+    `  rootLeaf,`,
+    `  rootList,`,
+    `  scalarField,`,
+    `  type ErrorSpec,`,
+    `  type Query,`,
+    `  type TypeMeta,`,
+    `} from "@distilled.cloud/core/graphql";`,
     "",
-    "export type Scalars = {",
   ];
-  for (const [name, type] of Object.entries(model.types)) {
-    if (type.kind === "SCALAR" || type.kind === "ENUM")
-      lines.push(
-        `${literal(name)}: ${type.kind === "SCALAR" ? (type.scalar ?? "unknown") : union(type.enumValues!.map(literal))};`,
-      );
-  }
-  lines.push("}", "export type Inputs = {");
-  for (const [name, type] of Object.entries(model.types)) {
-    if (type.kind === "INPUT_OBJECT")
-      lines.push(
-        documentation(type.description),
-        `${literal(name)}: ${argsType(type.inputFields ?? {})};`,
-      );
-  }
-  lines.push("}");
+
   const categories: Record<string, string> = {
     auth: "withAuthError",
     badRequest: "withBadRequestError",
@@ -323,97 +445,132 @@ export const generateGraphQLClient = (
     server: "withServerError",
     conflict: "withConflictError",
   };
-  for (const [tag, error] of Object.entries(model.errors)) {
-    const name = errorNames.get(tag)!;
+  for (const tag of errorTags) {
+    const error = model.errors[tag]!;
+    if (error.category && !categories[error.category])
+      throw new Error(
+        `GraphQL error ${tag}: unknown category ${error.category}`,
+      );
     const pipes = [
-      error.category
-        ? categories[error.category] && `Category.${categories[error.category]}`
-        : undefined,
+      error.category ? `Category.${categories[error.category]}` : undefined,
       error.retryable
         ? `Category.withRetryable(${error.category === "throttling" ? "{ throttling: true }" : ""})`
         : undefined,
     ].filter(Boolean);
+    const options = [
+      error.retryable ? "retryable: true" : undefined,
+      globalErrors.includes(tag) ? "global: true" : undefined,
+    ].filter(Boolean);
     lines.push(
-      documentation(error.description),
-      `export class ${name} extends S.TaggedError<${name}>()(${literal(tag)}, G.errorFields)${pipes.length ? `.pipe(${pipes.join(", ")})` : ""} {}`,
+      documentation(error.description) +
+        `export class ${tag} extends S.TaggedError<${tag}>()(${literal(tag)}, errorFields)${pipes.length ? `.pipe(${pipes.join(", ")})` : ""} {}`,
+      `const ${tag}Spec: ErrorSpec<${tag}> = errorSpec(${tag}, ${literal(tag)}, ${JSON.stringify(error.matchers)}${options.length ? `, { ${options.join(", ")} }` : ""});`,
+      "",
     );
   }
-  lines.push("export type Errors = {");
-  for (const [tag, name] of errorNames) lines.push(`${literal(tag)}: ${name};`);
-  lines.push("}", "export type Types = {");
-  for (const [name, type] of Object.entries(model.types)) {
-    if (!["OBJECT", "INTERFACE", "UNION"].includes(type.kind)) continue;
-    lines.push(documentation(type.description), `${literal(name)}: {`);
+  lines.push(
+    `/** Errors every ${sdkName} root field can return. */`,
+    `export type ${globalErrorType} = ${union(globalErrors)};`,
+    `const globalErrors: ReadonlyArray<ErrorSpec> = [${globalErrors.map((tag) => `${tag}Spec`).join(", ")}];`,
+    "",
+    `/** Every typed error the ${sdkName} SDK declares. */`,
+    `export type ${sdkName}Error = ${union(errorTags)};`,
+    "",
+  );
+
+  for (const name of enums) {
+    const type = model.types[name]!;
+    lines.push(
+      documentation(type.description) +
+        `export type ${name} = ${union((type.enumValues ?? []).map(literal))};`,
+      "",
+    );
+  }
+
+  for (const name of inputs) {
+    const type = model.types[name]!;
+    const fields = Object.entries(type.inputFields ?? {}).map(
+      ([fieldName, field]) =>
+        `  readonly ${fieldName}${field.type.endsWith("!") ? "" : "?"}: ${tsArg(field.type)};`,
+    );
+    lines.push(
+      documentation(type.description) + `export interface ${name} {`,
+      ...fields,
+      "}",
+      "",
+    );
+  }
+
+  for (const name of unions) {
+    const type = model.types[name]!;
+    lines.push(
+      documentation(type.description) +
+        `export type ${name} = ${(type.possibleTypes ?? []).join(" | ") || "unknown"};`,
+      "",
+    );
+  }
+
+  for (const name of objects) {
+    const type = model.types[name]!;
+    const fields = Object.entries(type.fields ?? {}).map(
+      ([fieldName, field]) =>
+        `  readonly ${fieldName}: ${tsOutput(field.type)};`,
+    );
+    lines.push(
+      documentation(type.description) + `export interface ${name} {`,
+      ...fields,
+      "}",
+      "",
+    );
+  }
+
+  for (const name of [...objects, ...unions]) {
+    lines.push(
+      `export const ${name}: TypeMeta = { name: ${JSON.stringify(name)}, fields: {} };`,
+    );
+  }
+  lines.push("");
+
+  for (const name of objects) {
+    const type = model.types[name]!;
+    lines.push(`Object.assign(${name}.fields, {`);
     for (const [fieldName, field] of Object.entries(type.fields ?? {})) {
-      lines.push(
-        documentation(field.description),
-        `${literal(fieldName)}: G.Field<${argsType(field.args)}, ${literal(field.type)}, ${union(field.errors.map(literal))}>;`,
-      );
+      lines.push(`  ${fieldName}: ${fieldMeta(fieldName, field)},`);
     }
-    lines.push("};");
+    lines.push("});", "");
   }
-  lines.push("}", "export type PossibleTypes = {");
-  for (const [name, type] of Object.entries(model.types)) {
-    if (type.kind === "INTERFACE" || type.kind === "UNION")
-      lines.push(
-        `${literal(name)}: ${union((type.possibleTypes ?? []).map(literal))};`,
-      );
+  for (const name of unions) {
+    lines.push(
+      `Object.assign(${name}.fields, { __typename: scalarField("__typename") });`,
+      "",
+    );
   }
-  lines.push(
-    "}",
-    "export type Schema = {",
-    "types: Types; scalars: Scalars; errors: Errors; possibleTypes: PossibleTypes;",
-    `query: ${literal(model.queryType)};`,
-    `mutation: ${model.mutationType ? literal(model.mutationType) : "never"};`,
-    `subscription: ${model.subscriptionType ? literal(model.subscriptionType) : "never"};`,
-    `globalErrors: ${union(model.globalErrors.map(literal))};`,
-    "};",
-  );
-  lines.push(
-    "export type Selection<Name extends keyof Types> = G.Selection<Schema, Name>;",
-    "export type Result<Name extends string, Select> = G.Result<Schema, Name, Select>;",
-    "export type SelectedErrors<Name extends keyof Types, Select> = G.Errors<Schema, Name, Select>;",
-  );
-  lines.push(`export const schema: G.GraphQLModel = ${JSON.stringify(model)};`);
-  lines.push(
-    `export const errorClasses = { ${[...errorNames].map(([tag, name]) => `${literal(tag)}: ${name}`).join(", ")} };`,
-  );
-  lines.push(
-    `export const client = G.makeClient<Schema, ${options.requirementsType}>(schema, ${options.transportName ?? "transport"}, errorClasses);`,
-    "export const query = client.query;",
-    "export const mutation = client.mutation;",
-    "export const report = client.report;",
-  );
-  const operationNames = new Map<string, string>();
-  for (const [kind, name] of [
-    ["query", model.queryType],
-    ["mutation", model.mutationType],
-  ] as const) {
-    for (const field of Object.keys(model.types[name ?? ""]?.fields ?? {})) {
-      const exportName = allocate(
-        field,
-        `${kind}${field[0]!.toUpperCase()}${field.slice(1)}`,
-      );
-      if (!operationNames.has(field)) operationNames.set(field, exportName);
-      lines.push(
-        `export const ${exportName} = client.operation(${literal(kind)}, ${literal(field)});`,
-      );
+
+  lines.push(`export const ${sdkName} = {`);
+  const queryNames = new Set<string>();
+  const queryType = model.types[model.queryType];
+  if (queryType?.fields) {
+    for (const [fieldName, field] of Object.entries(queryType.fields)) {
+      queryNames.add(fieldName);
+      lines.push(rootFn("query", fieldName, field));
     }
   }
-  for (const [alias, target] of Object.entries(
-    options.operationAliases ?? {},
-  )) {
-    const targetName = operationNames.get(target);
-    // Legacy aliases are optional conveniences; never displace a real export.
-    if (
-      targetName &&
-      alias !== target &&
-      identifier(alias) === alias &&
-      !occupied.has(alias)
-    ) {
-      occupied.add(alias);
-      lines.push(`export const ${alias} = ${targetName};`);
+  if (model.mutationType) {
+    const mutationType = model.types[model.mutationType];
+    if (mutationType?.fields) {
+      for (const [fieldName, field] of Object.entries(mutationType.fields)) {
+        const exportName = queryNames.has(fieldName)
+          ? `${fieldName}Mutation`
+          : fieldName;
+        const line = rootFn("mutation", fieldName, field);
+        lines.push(
+          exportName === fieldName
+            ? line
+            : line.replace(`  ${fieldName}:`, `  ${exportName}:`),
+        );
+      }
     }
   }
+  lines.push("};", "");
   return lines.join("\n") + "\n";
 };

package/src/codegen/openapi-binary.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test";
+import { convertOpenApiToSmithy } from "./openapi.ts";
+
+const model = (
+  schema: unknown,
+  mediaType = "multipart/form-data",
+  responseSchema: unknown = { type: "string", format: "binary" },
+  components: Record<string, unknown> = {},
+  options: { binaryTypes?: boolean } = { binaryTypes: true },
+) =>
+  convertOpenApiToSmithy(
+    {
+      openapi: "3.0.3",
+      info: { title: "Binary", version: "1" },
+      components,
+      paths: {
+        "/files": {
+          post: {
+            operationId: "uploadFile",
+            requestBody: { content: { [mediaType]: { schema } } },
+            responses: {
+              "200": {
+                content: {
+                  "application/octet-stream": {
+                    schema: responseSchema,
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+    { namespace: "com.example.binary", serviceName: "Binary", ...options },
+  );
+
+describe("OpenAPI binary contracts", () => {
+  for (const options of [{}, { binaryTypes: false }]) {
+    test(`binary conversion preserves existing contracts with ${JSON.stringify(options)}`, () => {
+      const result = model(
+        {
+          type: "object",
+          properties: {
+            zip: { type: "string", format: "binary" },
+            archive: { $ref: "#/components/schemas/Archive" },
+          },
+        },
+        "multipart/form-data",
+        { $ref: "#/components/schemas/Archive" },
+        { schemas: { Archive: { type: "string", format: "binary" } } },
+        options,
+      );
+      const request = result.shapes["com.example.binary#UploadFileRequest"];
+      expect(request.members.zip.target).toBe("smithy.api#String");
+      expect(request.members.archive.target).toBe("smithy.api#String");
+      expect(result.shapes["com.example.binary#UploadFile"].output.target).toBe(
+        "smithy.api#Unit",
+      );
+      expect(
+        result.shapes["com.example.binary#UploadFileResponse"],
+      ).toBeUndefined();
+    });
+  }
+
+  test("component-referenced binary responses retain the original reference's nullability", () => {
+    const result = model(
+      { type: "object" },
+      "application/json",
+      { $ref: "#/components/schemas/Archive", nullable: true },
+      { schemas: { Archive: { type: "string", format: "binary" } } },
+    );
+    const body =
+      result.shapes["com.example.binary#UploadFileResponse"].members.body;
+    expect(body.target).toBe("smithy.api#Blob");
+    expect(body.traits["com.distilled.openapi#rawResponse"]).toEqual({});
+    expect(body.traits["com.distilled.openapi#nullable"]).toEqual({});
+  });
+
+  test("multipart binary fields become blobs, not text or base64", () => {
+    const result = model({
+      type: "object",
+      properties: {
+        zip: { type: "string", format: "binary" },
+        encoded: { type: "string", format: "byte" },
+        environment: { type: "string" },
+      },
+    });
+    const request = result.shapes["com.example.binary#UploadFileRequest"];
+    expect(request.members.zip.target).toBe("smithy.api#Blob");
+    expect(request.members.encoded.target).toBe("smithy.api#String");
+    expect(request.members.environment.target).toBe("smithy.api#String");
+    const response = result.shapes["com.example.binary#UploadFileResponse"];
+    expect(response.members.body.target).toBe("smithy.api#Blob");
+    expect(
+      response.members.body.traits["com.distilled.openapi#rawResponse"],
+    ).toEqual({});
+  });
+});